21 #define SQLITE_AMALGAMATION 1 22 #ifndef SQLITE_PRIVATE 23 # define SQLITE_PRIVATE static 75 # define SQLITE_TCLAPI 82 #if defined(_MSC_VER) && _MSC_VER>=1400 108 #ifndef SQLITE_MSVC_H 109 #define SQLITE_MSVC_H 111 #if defined(_MSC_VER) 112 #pragma warning(disable : 4054) 113 #pragma warning(disable : 4055) 114 #pragma warning(disable : 4100) 115 #pragma warning(disable : 4127) 116 #pragma warning(disable : 4130) 117 #pragma warning(disable : 4152) 118 #pragma warning(disable : 4189) 119 #pragma warning(disable : 4206) 120 #pragma warning(disable : 4210) 121 #pragma warning(disable : 4232) 122 #pragma warning(disable : 4244) 123 #pragma warning(disable : 4305) 124 #pragma warning(disable : 4306) 125 #pragma warning(disable : 4702) 126 #pragma warning(disable : 4706) 153 #if defined(__RTP__) || defined(_WRS_KERNEL) 159 #define SQLITE_OS_OTHER 0 160 #define SQLITE_HOMEGROWN_RECURSIVE_MUTEX 1 161 #define SQLITE_OMIT_LOAD_EXTENSION 1 162 #define SQLITE_ENABLE_LOCKING_STYLE 0 167 #define HAVE_FCHOWN 1 168 #define HAVE_READLINK 1 199 #ifndef SQLITE_DISABLE_LFS 200 # define _LARGE_FILE 1 201 # ifndef _FILE_OFFSET_BITS 202 # define _FILE_OFFSET_BITS 64 204 # define _LARGEFILE_SOURCE 1 209 # define GCC_VERSION (__GNUC__*1000000+__GNUC_MINOR__*1000+__GNUC_PATCHLEVEL__) 211 # define GCC_VERSION 0 215 #if defined(__GNUC__) && !defined(_GNU_SOURCE) 219 #if defined(__OpenBSD__) && !defined(_BSD_SOURCE) 237 #if defined(_HAVE_MINGW_H) 239 #elif defined(_HAVE__MINGW_H) 248 #if !defined(_USE_32BIT_TIME_T) && !defined(_USE_64BIT_TIME_T) && \ 249 defined(_WIN32) && !defined(_WIN64) && \ 250 defined(__MINGW_MAJOR_VERSION) && __MINGW_MAJOR_VERSION >= 4 && \ 252 # define _USE_32BIT_TIME_T 308 #ifndef SQLITE_EXTERN 309 # define SQLITE_EXTERN extern 315 # define SQLITE_CDECL 317 #ifndef SQLITE_APICALL 318 # define SQLITE_APICALL 320 #ifndef SQLITE_STDCALL 321 # define SQLITE_STDCALL SQLITE_APICALL 323 #ifndef SQLITE_CALLBACK 324 # define SQLITE_CALLBACK 326 #ifndef SQLITE_SYSAPI 327 # define SQLITE_SYSAPI 343 #define SQLITE_DEPRECATED 344 #define SQLITE_EXPERIMENTAL 349 #ifdef SQLITE_VERSION 350 # undef SQLITE_VERSION 352 #ifdef SQLITE_VERSION_NUMBER 353 # undef SQLITE_VERSION_NUMBER 383 #define SQLITE_VERSION "3.14.1" 384 #define SQLITE_VERSION_NUMBER 3014001 385 #define SQLITE_SOURCE_ID "2016-08-11 18:53:32 a12d8059770df4bca59e321c266410344242bf7b" 417 SQLITE_API
const char sqlite3_version[] = SQLITE_VERSION;
418 SQLITE_API
const char *SQLITE_STDCALL sqlite3_libversion(
void);
419 SQLITE_API
const char *SQLITE_STDCALL sqlite3_sourceid(
void);
420 SQLITE_API
int SQLITE_STDCALL sqlite3_libversion_number(
void);
444 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS 445 SQLITE_API
int SQLITE_STDCALL sqlite3_compileoption_used(
const char *zOptName);
446 SQLITE_API
const char *SQLITE_STDCALL sqlite3_compileoption_get(
int N);
485 SQLITE_API
int SQLITE_STDCALL sqlite3_threadsafe(
void);
519 #ifdef SQLITE_INT64_TYPE 520 typedef SQLITE_INT64_TYPE sqlite_int64;
521 typedef unsigned SQLITE_INT64_TYPE sqlite_uint64;
522 #elif defined(_MSC_VER) || defined(__BORLANDC__) 523 typedef __int64 sqlite_int64;
524 typedef unsigned __int64 sqlite_uint64;
526 typedef long long int sqlite_int64;
527 typedef unsigned long long int sqlite_uint64;
529 typedef sqlite_int64 sqlite3_int64;
530 typedef sqlite_uint64 sqlite3_uint64;
536 #ifdef SQLITE_OMIT_FLOATING_POINT 537 # define double sqlite3_int64 582 SQLITE_API
int SQLITE_STDCALL sqlite3_close(
sqlite3*);
583 SQLITE_API
int SQLITE_STDCALL sqlite3_close_v2(
sqlite3*);
590 typedef int (*sqlite3_callback)(
void*,int,
char**,
char**);
654 SQLITE_API
int SQLITE_STDCALL sqlite3_exec(
657 int (*callback)(
void*,
int,
char**,
char**),
675 #define SQLITE_ERROR 1 676 #define SQLITE_INTERNAL 2 677 #define SQLITE_PERM 3 678 #define SQLITE_ABORT 4 679 #define SQLITE_BUSY 5 680 #define SQLITE_LOCKED 6 681 #define SQLITE_NOMEM 7 682 #define SQLITE_READONLY 8 683 #define SQLITE_INTERRUPT 9 684 #define SQLITE_IOERR 10 685 #define SQLITE_CORRUPT 11 686 #define SQLITE_NOTFOUND 12 687 #define SQLITE_FULL 13 688 #define SQLITE_CANTOPEN 14 689 #define SQLITE_PROTOCOL 15 690 #define SQLITE_EMPTY 16 691 #define SQLITE_SCHEMA 17 692 #define SQLITE_TOOBIG 18 693 #define SQLITE_CONSTRAINT 19 694 #define SQLITE_MISMATCH 20 695 #define SQLITE_MISUSE 21 696 #define SQLITE_NOLFS 22 697 #define SQLITE_AUTH 23 698 #define SQLITE_FORMAT 24 699 #define SQLITE_RANGE 25 700 #define SQLITE_NOTADB 26 701 #define SQLITE_NOTICE 27 702 #define SQLITE_WARNING 28 703 #define SQLITE_ROW 100 704 #define SQLITE_DONE 101 723 #define SQLITE_IOERR_READ (SQLITE_IOERR | (1<<8)) 724 #define SQLITE_IOERR_SHORT_READ (SQLITE_IOERR | (2<<8)) 725 #define SQLITE_IOERR_WRITE (SQLITE_IOERR | (3<<8)) 726 #define SQLITE_IOERR_FSYNC (SQLITE_IOERR | (4<<8)) 727 #define SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR | (5<<8)) 728 #define SQLITE_IOERR_TRUNCATE (SQLITE_IOERR | (6<<8)) 729 #define SQLITE_IOERR_FSTAT (SQLITE_IOERR | (7<<8)) 730 #define SQLITE_IOERR_UNLOCK (SQLITE_IOERR | (8<<8)) 731 #define SQLITE_IOERR_RDLOCK (SQLITE_IOERR | (9<<8)) 732 #define SQLITE_IOERR_DELETE (SQLITE_IOERR | (10<<8)) 733 #define SQLITE_IOERR_BLOCKED (SQLITE_IOERR | (11<<8)) 734 #define SQLITE_IOERR_NOMEM (SQLITE_IOERR | (12<<8)) 735 #define SQLITE_IOERR_ACCESS (SQLITE_IOERR | (13<<8)) 736 #define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8)) 737 #define SQLITE_IOERR_LOCK (SQLITE_IOERR | (15<<8)) 738 #define SQLITE_IOERR_CLOSE (SQLITE_IOERR | (16<<8)) 739 #define SQLITE_IOERR_DIR_CLOSE (SQLITE_IOERR | (17<<8)) 740 #define SQLITE_IOERR_SHMOPEN (SQLITE_IOERR | (18<<8)) 741 #define SQLITE_IOERR_SHMSIZE (SQLITE_IOERR | (19<<8)) 742 #define SQLITE_IOERR_SHMLOCK (SQLITE_IOERR | (20<<8)) 743 #define SQLITE_IOERR_SHMMAP (SQLITE_IOERR | (21<<8)) 744 #define SQLITE_IOERR_SEEK (SQLITE_IOERR | (22<<8)) 745 #define SQLITE_IOERR_DELETE_NOENT (SQLITE_IOERR | (23<<8)) 746 #define SQLITE_IOERR_MMAP (SQLITE_IOERR | (24<<8)) 747 #define SQLITE_IOERR_GETTEMPPATH (SQLITE_IOERR | (25<<8)) 748 #define SQLITE_IOERR_CONVPATH (SQLITE_IOERR | (26<<8)) 749 #define SQLITE_IOERR_VNODE (SQLITE_IOERR | (27<<8)) 750 #define SQLITE_IOERR_AUTH (SQLITE_IOERR | (28<<8)) 751 #define SQLITE_LOCKED_SHAREDCACHE (SQLITE_LOCKED | (1<<8)) 752 #define SQLITE_BUSY_RECOVERY (SQLITE_BUSY | (1<<8)) 753 #define SQLITE_BUSY_SNAPSHOT (SQLITE_BUSY | (2<<8)) 754 #define SQLITE_CANTOPEN_NOTEMPDIR (SQLITE_CANTOPEN | (1<<8)) 755 #define SQLITE_CANTOPEN_ISDIR (SQLITE_CANTOPEN | (2<<8)) 756 #define SQLITE_CANTOPEN_FULLPATH (SQLITE_CANTOPEN | (3<<8)) 757 #define SQLITE_CANTOPEN_CONVPATH (SQLITE_CANTOPEN | (4<<8)) 758 #define SQLITE_CORRUPT_VTAB (SQLITE_CORRUPT | (1<<8)) 759 #define SQLITE_READONLY_RECOVERY (SQLITE_READONLY | (1<<8)) 760 #define SQLITE_READONLY_CANTLOCK (SQLITE_READONLY | (2<<8)) 761 #define SQLITE_READONLY_ROLLBACK (SQLITE_READONLY | (3<<8)) 762 #define SQLITE_READONLY_DBMOVED (SQLITE_READONLY | (4<<8)) 763 #define SQLITE_ABORT_ROLLBACK (SQLITE_ABORT | (2<<8)) 764 #define SQLITE_CONSTRAINT_CHECK (SQLITE_CONSTRAINT | (1<<8)) 765 #define SQLITE_CONSTRAINT_COMMITHOOK (SQLITE_CONSTRAINT | (2<<8)) 766 #define SQLITE_CONSTRAINT_FOREIGNKEY (SQLITE_CONSTRAINT | (3<<8)) 767 #define SQLITE_CONSTRAINT_FUNCTION (SQLITE_CONSTRAINT | (4<<8)) 768 #define SQLITE_CONSTRAINT_NOTNULL (SQLITE_CONSTRAINT | (5<<8)) 769 #define SQLITE_CONSTRAINT_PRIMARYKEY (SQLITE_CONSTRAINT | (6<<8)) 770 #define SQLITE_CONSTRAINT_TRIGGER (SQLITE_CONSTRAINT | (7<<8)) 771 #define SQLITE_CONSTRAINT_UNIQUE (SQLITE_CONSTRAINT | (8<<8)) 772 #define SQLITE_CONSTRAINT_VTAB (SQLITE_CONSTRAINT | (9<<8)) 773 #define SQLITE_CONSTRAINT_ROWID (SQLITE_CONSTRAINT |(10<<8)) 774 #define SQLITE_NOTICE_RECOVER_WAL (SQLITE_NOTICE | (1<<8)) 775 #define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8)) 776 #define SQLITE_WARNING_AUTOINDEX (SQLITE_WARNING | (1<<8)) 777 #define SQLITE_AUTH_USER (SQLITE_AUTH | (1<<8)) 778 #define SQLITE_OK_LOAD_PERMANENTLY (SQLITE_OK | (1<<8)) 787 #define SQLITE_OPEN_READONLY 0x00000001 788 #define SQLITE_OPEN_READWRITE 0x00000002 789 #define SQLITE_OPEN_CREATE 0x00000004 790 #define SQLITE_OPEN_DELETEONCLOSE 0x00000008 791 #define SQLITE_OPEN_EXCLUSIVE 0x00000010 792 #define SQLITE_OPEN_AUTOPROXY 0x00000020 793 #define SQLITE_OPEN_URI 0x00000040 794 #define SQLITE_OPEN_MEMORY 0x00000080 795 #define SQLITE_OPEN_MAIN_DB 0x00000100 796 #define SQLITE_OPEN_TEMP_DB 0x00000200 797 #define SQLITE_OPEN_TRANSIENT_DB 0x00000400 798 #define SQLITE_OPEN_MAIN_JOURNAL 0x00000800 799 #define SQLITE_OPEN_TEMP_JOURNAL 0x00001000 800 #define SQLITE_OPEN_SUBJOURNAL 0x00002000 801 #define SQLITE_OPEN_MASTER_JOURNAL 0x00004000 802 #define SQLITE_OPEN_NOMUTEX 0x00008000 803 #define SQLITE_OPEN_FULLMUTEX 0x00010000 804 #define SQLITE_OPEN_SHAREDCACHE 0x00020000 805 #define SQLITE_OPEN_PRIVATECACHE 0x00040000 806 #define SQLITE_OPEN_WAL 0x00080000 838 #define SQLITE_IOCAP_ATOMIC 0x00000001 839 #define SQLITE_IOCAP_ATOMIC512 0x00000002 840 #define SQLITE_IOCAP_ATOMIC1K 0x00000004 841 #define SQLITE_IOCAP_ATOMIC2K 0x00000008 842 #define SQLITE_IOCAP_ATOMIC4K 0x00000010 843 #define SQLITE_IOCAP_ATOMIC8K 0x00000020 844 #define SQLITE_IOCAP_ATOMIC16K 0x00000040 845 #define SQLITE_IOCAP_ATOMIC32K 0x00000080 846 #define SQLITE_IOCAP_ATOMIC64K 0x00000100 847 #define SQLITE_IOCAP_SAFE_APPEND 0x00000200 848 #define SQLITE_IOCAP_SEQUENTIAL 0x00000400 849 #define SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN 0x00000800 850 #define SQLITE_IOCAP_POWERSAFE_OVERWRITE 0x00001000 851 #define SQLITE_IOCAP_IMMUTABLE 0x00002000 860 #define SQLITE_LOCK_NONE 0 861 #define SQLITE_LOCK_SHARED 1 862 #define SQLITE_LOCK_RESERVED 2 863 #define SQLITE_LOCK_PENDING 3 864 #define SQLITE_LOCK_EXCLUSIVE 4 892 #define SQLITE_SYNC_NORMAL 0x00002 893 #define SQLITE_SYNC_FULL 0x00003 894 #define SQLITE_SYNC_DATAONLY 0x00010 1003 struct sqlite3_io_methods {
1006 int (*xRead)(
sqlite3_file*,
void*,
int iAmt, sqlite3_int64 iOfst);
1007 int (*xWrite)(
sqlite3_file*,
const void*,
int iAmt, sqlite3_int64 iOfst);
1013 int (*xCheckReservedLock)(
sqlite3_file*,
int *pResOut);
1014 int (*xFileControl)(
sqlite3_file*,
int op,
void *pArg);
1018 int (*xShmMap)(
sqlite3_file*,
int iPg,
int pgsz, int,
void volatile**);
1019 int (*xShmLock)(
sqlite3_file*,
int offset,
int n,
int flags);
1023 int (*xFetch)(
sqlite3_file*, sqlite3_int64 iOfst,
int iAmt,
void **pp);
1024 int (*xUnfetch)(
sqlite3_file*, sqlite3_int64 iOfst,
void *p);
1262 #define SQLITE_FCNTL_LOCKSTATE 1 1263 #define SQLITE_FCNTL_GET_LOCKPROXYFILE 2 1264 #define SQLITE_FCNTL_SET_LOCKPROXYFILE 3 1265 #define SQLITE_FCNTL_LAST_ERRNO 4 1266 #define SQLITE_FCNTL_SIZE_HINT 5 1267 #define SQLITE_FCNTL_CHUNK_SIZE 6 1268 #define SQLITE_FCNTL_FILE_POINTER 7 1269 #define SQLITE_FCNTL_SYNC_OMITTED 8 1270 #define SQLITE_FCNTL_WIN32_AV_RETRY 9 1271 #define SQLITE_FCNTL_PERSIST_WAL 10 1272 #define SQLITE_FCNTL_OVERWRITE 11 1273 #define SQLITE_FCNTL_VFSNAME 12 1274 #define SQLITE_FCNTL_POWERSAFE_OVERWRITE 13 1275 #define SQLITE_FCNTL_PRAGMA 14 1276 #define SQLITE_FCNTL_BUSYHANDLER 15 1277 #define SQLITE_FCNTL_TEMPFILENAME 16 1278 #define SQLITE_FCNTL_MMAP_SIZE 18 1279 #define SQLITE_FCNTL_TRACE 19 1280 #define SQLITE_FCNTL_HAS_MOVED 20 1281 #define SQLITE_FCNTL_SYNC 21 1282 #define SQLITE_FCNTL_COMMIT_PHASETWO 22 1283 #define SQLITE_FCNTL_WIN32_SET_HANDLE 23 1284 #define SQLITE_FCNTL_WAL_BLOCK 24 1285 #define SQLITE_FCNTL_ZIPVFS 25 1286 #define SQLITE_FCNTL_RBU 26 1287 #define SQLITE_FCNTL_VFS_POINTER 27 1288 #define SQLITE_FCNTL_JOURNAL_POINTER 28 1291 #define SQLITE_GET_LOCKPROXYFILE SQLITE_FCNTL_GET_LOCKPROXYFILE 1292 #define SQLITE_SET_LOCKPROXYFILE SQLITE_FCNTL_SET_LOCKPROXYFILE 1293 #define SQLITE_LAST_ERRNO SQLITE_FCNTL_LAST_ERRNO 1476 typedef void (*sqlite3_syscall_ptr)(void);
1477 struct sqlite3_vfs {
1484 int (*xOpen)(sqlite3_vfs*,
const char *zName,
sqlite3_file*,
1485 int flags,
int *pOutFlags);
1486 int (*xDelete)(sqlite3_vfs*,
const char *zName,
int syncDir);
1487 int (*xAccess)(sqlite3_vfs*,
const char *zName,
int flags,
int *pResOut);
1488 int (*xFullPathname)(sqlite3_vfs*,
const char *zName,
int nOut,
char *zOut);
1489 void *(*xDlOpen)(sqlite3_vfs*,
const char *zFilename);
1490 void (*xDlError)(sqlite3_vfs*,
int nByte,
char *zErrMsg);
1491 void (*(*xDlSym)(sqlite3_vfs*,
void*,
const char *zSymbol))(void);
1492 void (*xDlClose)(sqlite3_vfs*,
void*);
1493 int (*xRandomness)(sqlite3_vfs*,
int nByte,
char *zOut);
1494 int (*xSleep)(sqlite3_vfs*,
int microseconds);
1495 int (*xCurrentTime)(sqlite3_vfs*,
double*);
1496 int (*xGetLastError)(sqlite3_vfs*, int,
char *);
1501 int (*xCurrentTimeInt64)(sqlite3_vfs*, sqlite3_int64*);
1506 int (*xSetSystemCall)(sqlite3_vfs*,
const char *zName, sqlite3_syscall_ptr);
1507 sqlite3_syscall_ptr (*xGetSystemCall)(sqlite3_vfs*,
const char *zName);
1508 const char *(*xNextSystemCall)(sqlite3_vfs*,
const char *zName);
1536 #define SQLITE_ACCESS_EXISTS 0 1537 #define SQLITE_ACCESS_READWRITE 1 1538 #define SQLITE_ACCESS_READ 2 1562 #define SQLITE_SHM_UNLOCK 1 1563 #define SQLITE_SHM_LOCK 2 1564 #define SQLITE_SHM_SHARED 4 1565 #define SQLITE_SHM_EXCLUSIVE 8 1575 #define SQLITE_SHM_NLOCK 8 1653 SQLITE_API
int SQLITE_STDCALL sqlite3_initialize(
void);
1654 SQLITE_API
int SQLITE_STDCALL sqlite3_shutdown(
void);
1655 SQLITE_API
int SQLITE_STDCALL sqlite3_os_init(
void);
1656 SQLITE_API
int SQLITE_STDCALL sqlite3_os_end(
void);
1689 SQLITE_API
int SQLITE_CDECL sqlite3_config(
int, ...);
1708 SQLITE_API
int SQLITE_CDECL sqlite3_db_config(
sqlite3*,
int op, ...);
1774 struct sqlite3_mem_methods {
1775 void *(*xMalloc)(int);
1776 void (*xFree)(
void*);
1777 void *(*xRealloc)(
void*,int);
1778 int (*xSize)(
void*);
1779 int (*xRoundup)(int);
1780 int (*xInit)(
void*);
1781 void (*xShutdown)(
void*);
2119 #define SQLITE_CONFIG_SINGLETHREAD 1 2120 #define SQLITE_CONFIG_MULTITHREAD 2 2121 #define SQLITE_CONFIG_SERIALIZED 3 2122 #define SQLITE_CONFIG_MALLOC 4 2123 #define SQLITE_CONFIG_GETMALLOC 5 2124 #define SQLITE_CONFIG_SCRATCH 6 2125 #define SQLITE_CONFIG_PAGECACHE 7 2126 #define SQLITE_CONFIG_HEAP 8 2127 #define SQLITE_CONFIG_MEMSTATUS 9 2128 #define SQLITE_CONFIG_MUTEX 10 2129 #define SQLITE_CONFIG_GETMUTEX 11 2131 #define SQLITE_CONFIG_LOOKASIDE 13 2132 #define SQLITE_CONFIG_PCACHE 14 2133 #define SQLITE_CONFIG_GETPCACHE 15 2134 #define SQLITE_CONFIG_LOG 16 2135 #define SQLITE_CONFIG_URI 17 2136 #define SQLITE_CONFIG_PCACHE2 18 2137 #define SQLITE_CONFIG_GETPCACHE2 19 2138 #define SQLITE_CONFIG_COVERING_INDEX_SCAN 20 2139 #define SQLITE_CONFIG_SQLLOG 21 2140 #define SQLITE_CONFIG_MMAP_SIZE 22 2141 #define SQLITE_CONFIG_WIN32_HEAPSIZE 23 2142 #define SQLITE_CONFIG_PCACHE_HDRSZ 24 2143 #define SQLITE_CONFIG_PMASZ 25 2144 #define SQLITE_CONFIG_STMTJRNL_SPILL 26 2234 #define SQLITE_DBCONFIG_LOOKASIDE 1001 2235 #define SQLITE_DBCONFIG_ENABLE_FKEY 1002 2236 #define SQLITE_DBCONFIG_ENABLE_TRIGGER 1003 2237 #define SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER 1004 2238 #define SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION 1005 2249 SQLITE_API
int SQLITE_STDCALL sqlite3_extended_result_codes(
sqlite3*,
int onoff);
2301 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_last_insert_rowid(
sqlite3*);
2354 SQLITE_API
int SQLITE_STDCALL sqlite3_changes(
sqlite3*);
2378 SQLITE_API
int SQLITE_STDCALL sqlite3_total_changes(
sqlite3*);
2418 SQLITE_API
void SQLITE_STDCALL sqlite3_interrupt(
sqlite3*);
2453 SQLITE_API
int SQLITE_STDCALL sqlite3_complete(
const char *sql);
2454 SQLITE_API
int SQLITE_STDCALL sqlite3_complete16(
const void *sql);
2515 SQLITE_API
int SQLITE_STDCALL sqlite3_busy_handler(
sqlite3*,
int(*)(
void*,
int),
void*);
2538 SQLITE_API
int SQLITE_STDCALL sqlite3_busy_timeout(
sqlite3*,
int ms);
2613 SQLITE_API
int SQLITE_STDCALL sqlite3_get_table(
2621 SQLITE_API
void SQLITE_STDCALL sqlite3_free_table(
char **result);
2727 SQLITE_API
char *SQLITE_CDECL sqlite3_mprintf(
const char*,...);
2728 SQLITE_API
char *SQLITE_STDCALL sqlite3_vmprintf(
const char*, va_list);
2729 SQLITE_API
char *SQLITE_CDECL sqlite3_snprintf(
int,
char*,
const char*, ...);
2730 SQLITE_API
char *SQLITE_STDCALL sqlite3_vsnprintf(
int,
char*,
const char*, va_list);
2820 SQLITE_API
void *SQLITE_STDCALL sqlite3_malloc(
int);
2821 SQLITE_API
void *SQLITE_STDCALL sqlite3_malloc64(sqlite3_uint64);
2822 SQLITE_API
void *SQLITE_STDCALL sqlite3_realloc(
void*,
int);
2823 SQLITE_API
void *SQLITE_STDCALL sqlite3_realloc64(
void*, sqlite3_uint64);
2824 SQLITE_API
void SQLITE_STDCALL sqlite3_free(
void*);
2825 SQLITE_API sqlite3_uint64 SQLITE_STDCALL sqlite3_msize(
void*);
2850 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_memory_used(
void);
2851 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_memory_highwater(
int resetFlag);
2874 SQLITE_API
void SQLITE_STDCALL sqlite3_randomness(
int N,
void *P);
2957 SQLITE_API
int SQLITE_STDCALL sqlite3_set_authorizer(
2959 int (*xAuth)(
void*,
int,
const char*,
const char*,
const char*,
const char*),
2975 #define SQLITE_DENY 1 2976 #define SQLITE_IGNORE 2 2998 #define SQLITE_CREATE_INDEX 1 2999 #define SQLITE_CREATE_TABLE 2 3000 #define SQLITE_CREATE_TEMP_INDEX 3 3001 #define SQLITE_CREATE_TEMP_TABLE 4 3002 #define SQLITE_CREATE_TEMP_TRIGGER 5 3003 #define SQLITE_CREATE_TEMP_VIEW 6 3004 #define SQLITE_CREATE_TRIGGER 7 3005 #define SQLITE_CREATE_VIEW 8 3006 #define SQLITE_DELETE 9 3007 #define SQLITE_DROP_INDEX 10 3008 #define SQLITE_DROP_TABLE 11 3009 #define SQLITE_DROP_TEMP_INDEX 12 3010 #define SQLITE_DROP_TEMP_TABLE 13 3011 #define SQLITE_DROP_TEMP_TRIGGER 14 3012 #define SQLITE_DROP_TEMP_VIEW 15 3013 #define SQLITE_DROP_TRIGGER 16 3014 #define SQLITE_DROP_VIEW 17 3015 #define SQLITE_INSERT 18 3016 #define SQLITE_PRAGMA 19 3017 #define SQLITE_READ 20 3018 #define SQLITE_SELECT 21 3019 #define SQLITE_TRANSACTION 22 3020 #define SQLITE_UPDATE 23 3021 #define SQLITE_ATTACH 24 3022 #define SQLITE_DETACH 25 3023 #define SQLITE_ALTER_TABLE 26 3024 #define SQLITE_REINDEX 27 3025 #define SQLITE_ANALYZE 28 3026 #define SQLITE_CREATE_VTABLE 29 3027 #define SQLITE_DROP_VTABLE 30 3028 #define SQLITE_FUNCTION 31 3029 #define SQLITE_SAVEPOINT 32 3030 #define SQLITE_COPY 0 3031 #define SQLITE_RECURSIVE 33 3065 SQLITE_API SQLITE_DEPRECATED
void *SQLITE_STDCALL sqlite3_trace(
sqlite3*,
3066 void(*xTrace)(
void*,
const char*),
void*);
3067 SQLITE_API SQLITE_DEPRECATED
void *SQLITE_STDCALL sqlite3_profile(
sqlite3*,
3068 void(*xProfile)(
void*,
const char*,sqlite3_uint64),
void*);
3122 #define SQLITE_TRACE_STMT 0x01 3123 #define SQLITE_TRACE_PROFILE 0x02 3124 #define SQLITE_TRACE_ROW 0x04 3125 #define SQLITE_TRACE_CLOSE 0x08 3156 SQLITE_API
int SQLITE_STDCALL sqlite3_trace_v2(
3159 int(*xCallback)(
unsigned,
void*,
void*,
void*),
3195 SQLITE_API
void SQLITE_STDCALL sqlite3_progress_handler(
sqlite3*,
int,
int(*)(
void*),
void*);
3424 SQLITE_API
int SQLITE_STDCALL sqlite3_open(
3425 const char *filename,
3428 SQLITE_API
int SQLITE_STDCALL sqlite3_open16(
3429 const void *filename,
3432 SQLITE_API
int SQLITE_STDCALL sqlite3_open_v2(
3433 const char *filename,
3478 SQLITE_API
const char *SQLITE_STDCALL sqlite3_uri_parameter(
const char *zFilename,
const char *zParam);
3479 SQLITE_API
int SQLITE_STDCALL sqlite3_uri_boolean(
const char *zFile,
const char *zParam,
int bDefault);
3480 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_uri_int64(
const char*,
const char*, sqlite3_int64);
3524 SQLITE_API
int SQLITE_STDCALL sqlite3_errcode(
sqlite3 *db);
3525 SQLITE_API
int SQLITE_STDCALL sqlite3_extended_errcode(
sqlite3 *db);
3526 SQLITE_API
const char *SQLITE_STDCALL sqlite3_errmsg(
sqlite3*);
3527 SQLITE_API
const void *SQLITE_STDCALL sqlite3_errmsg16(
sqlite3*);
3528 SQLITE_API
const char *SQLITE_STDCALL sqlite3_errstr(
int);
3554 typedef struct sqlite3_stmt sqlite3_stmt;
3596 SQLITE_API
int SQLITE_STDCALL sqlite3_limit(
sqlite3*,
int id,
int newVal);
3654 #define SQLITE_LIMIT_LENGTH 0 3655 #define SQLITE_LIMIT_SQL_LENGTH 1 3656 #define SQLITE_LIMIT_COLUMN 2 3657 #define SQLITE_LIMIT_EXPR_DEPTH 3 3658 #define SQLITE_LIMIT_COMPOUND_SELECT 4 3659 #define SQLITE_LIMIT_VDBE_OP 5 3660 #define SQLITE_LIMIT_FUNCTION_ARG 6 3661 #define SQLITE_LIMIT_ATTACHED 7 3662 #define SQLITE_LIMIT_LIKE_PATTERN_LENGTH 8 3663 #define SQLITE_LIMIT_VARIABLE_NUMBER 9 3664 #define SQLITE_LIMIT_TRIGGER_DEPTH 10 3665 #define SQLITE_LIMIT_WORKER_THREADS 11 3748 SQLITE_API
int SQLITE_STDCALL sqlite3_prepare(
3752 sqlite3_stmt **ppStmt,
3755 SQLITE_API
int SQLITE_STDCALL sqlite3_prepare_v2(
3759 sqlite3_stmt **ppStmt,
3762 SQLITE_API
int SQLITE_STDCALL sqlite3_prepare16(
3766 sqlite3_stmt **ppStmt,
3769 SQLITE_API
int SQLITE_STDCALL sqlite3_prepare16_v2(
3773 sqlite3_stmt **ppStmt,
3808 SQLITE_API
const char *SQLITE_STDCALL sqlite3_sql(sqlite3_stmt *pStmt);
3809 SQLITE_API
char *SQLITE_STDCALL sqlite3_expanded_sql(sqlite3_stmt *pStmt);
3841 SQLITE_API
int SQLITE_STDCALL sqlite3_stmt_readonly(sqlite3_stmt *pStmt);
3862 SQLITE_API
int SQLITE_STDCALL sqlite3_stmt_busy(sqlite3_stmt*);
3903 typedef struct Mem sqlite3_value;
4026 SQLITE_API
int SQLITE_STDCALL sqlite3_bind_blob(sqlite3_stmt*,
int,
const void*,
int n,
void(*)(
void*));
4027 SQLITE_API
int SQLITE_STDCALL sqlite3_bind_blob64(sqlite3_stmt*,
int,
const void*, sqlite3_uint64,
4029 SQLITE_API
int SQLITE_STDCALL sqlite3_bind_double(sqlite3_stmt*,
int,
double);
4030 SQLITE_API
int SQLITE_STDCALL sqlite3_bind_int(sqlite3_stmt*,
int,
int);
4031 SQLITE_API
int SQLITE_STDCALL sqlite3_bind_int64(sqlite3_stmt*,
int, sqlite3_int64);
4032 SQLITE_API
int SQLITE_STDCALL sqlite3_bind_null(sqlite3_stmt*,
int);
4033 SQLITE_API
int SQLITE_STDCALL sqlite3_bind_text(sqlite3_stmt*,
int,
const char*,
int,
void(*)(
void*));
4034 SQLITE_API
int SQLITE_STDCALL sqlite3_bind_text16(sqlite3_stmt*,
int,
const void*,
int,
void(*)(
void*));
4035 SQLITE_API
int SQLITE_STDCALL sqlite3_bind_text64(sqlite3_stmt*,
int,
const char*, sqlite3_uint64,
4036 void(*)(
void*),
unsigned char encoding);
4037 SQLITE_API
int SQLITE_STDCALL sqlite3_bind_value(sqlite3_stmt*,
int,
const sqlite3_value*);
4038 SQLITE_API
int SQLITE_STDCALL sqlite3_bind_zeroblob(sqlite3_stmt*,
int,
int n);
4039 SQLITE_API
int SQLITE_STDCALL sqlite3_bind_zeroblob64(sqlite3_stmt*,
int, sqlite3_uint64);
4060 SQLITE_API
int SQLITE_STDCALL sqlite3_bind_parameter_count(sqlite3_stmt*);
4088 SQLITE_API
const char *SQLITE_STDCALL sqlite3_bind_parameter_name(sqlite3_stmt*,
int);
4105 SQLITE_API
int SQLITE_STDCALL sqlite3_bind_parameter_index(sqlite3_stmt*,
const char *zName);
4115 SQLITE_API
int SQLITE_STDCALL sqlite3_clear_bindings(sqlite3_stmt*);
4127 SQLITE_API
int SQLITE_STDCALL sqlite3_column_count(sqlite3_stmt *pStmt);
4156 SQLITE_API
const char *SQLITE_STDCALL sqlite3_column_name(sqlite3_stmt*,
int N);
4157 SQLITE_API
const void *SQLITE_STDCALL sqlite3_column_name16(sqlite3_stmt*,
int N);
4205 SQLITE_API
const char *SQLITE_STDCALL sqlite3_column_database_name(sqlite3_stmt*,
int);
4206 SQLITE_API
const void *SQLITE_STDCALL sqlite3_column_database_name16(sqlite3_stmt*,
int);
4207 SQLITE_API
const char *SQLITE_STDCALL sqlite3_column_table_name(sqlite3_stmt*,
int);
4208 SQLITE_API
const void *SQLITE_STDCALL sqlite3_column_table_name16(sqlite3_stmt*,
int);
4209 SQLITE_API
const char *SQLITE_STDCALL sqlite3_column_origin_name(sqlite3_stmt*,
int);
4210 SQLITE_API
const void *SQLITE_STDCALL sqlite3_column_origin_name16(sqlite3_stmt*,
int);
4242 SQLITE_API
const char *SQLITE_STDCALL sqlite3_column_decltype(sqlite3_stmt*,
int);
4243 SQLITE_API
const void *SQLITE_STDCALL sqlite3_column_decltype16(sqlite3_stmt*,
int);
4323 SQLITE_API
int SQLITE_STDCALL sqlite3_step(sqlite3_stmt*);
4344 SQLITE_API
int SQLITE_STDCALL sqlite3_data_count(sqlite3_stmt *pStmt);
4367 #define SQLITE_INTEGER 1 4368 #define SQLITE_FLOAT 2 4369 #define SQLITE_BLOB 4 4370 #define SQLITE_NULL 5 4374 # define SQLITE_TEXT 3 4376 #define SQLITE3_TEXT 3 4534 SQLITE_API
const void *SQLITE_STDCALL sqlite3_column_blob(sqlite3_stmt*,
int iCol);
4535 SQLITE_API
int SQLITE_STDCALL sqlite3_column_bytes(sqlite3_stmt*,
int iCol);
4536 SQLITE_API
int SQLITE_STDCALL sqlite3_column_bytes16(sqlite3_stmt*,
int iCol);
4537 SQLITE_API
double SQLITE_STDCALL sqlite3_column_double(sqlite3_stmt*,
int iCol);
4538 SQLITE_API
int SQLITE_STDCALL sqlite3_column_int(sqlite3_stmt*,
int iCol);
4539 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_column_int64(sqlite3_stmt*,
int iCol);
4540 SQLITE_API
const unsigned char *SQLITE_STDCALL sqlite3_column_text(sqlite3_stmt*,
int iCol);
4541 SQLITE_API
const void *SQLITE_STDCALL sqlite3_column_text16(sqlite3_stmt*,
int iCol);
4542 SQLITE_API
int SQLITE_STDCALL sqlite3_column_type(sqlite3_stmt*,
int iCol);
4543 SQLITE_API sqlite3_value *SQLITE_STDCALL sqlite3_column_value(sqlite3_stmt*,
int iCol);
4571 SQLITE_API
int SQLITE_STDCALL sqlite3_finalize(sqlite3_stmt *pStmt);
4598 SQLITE_API
int SQLITE_STDCALL sqlite3_reset(sqlite3_stmt *pStmt);
4698 SQLITE_API
int SQLITE_STDCALL sqlite3_create_function(
4700 const char *zFunctionName,
4704 void (*xFunc)(sqlite3_context*,
int,sqlite3_value**),
4705 void (*xStep)(sqlite3_context*,
int,sqlite3_value**),
4706 void (*xFinal)(sqlite3_context*)
4708 SQLITE_API
int SQLITE_STDCALL sqlite3_create_function16(
4710 const void *zFunctionName,
4714 void (*xFunc)(sqlite3_context*,
int,sqlite3_value**),
4715 void (*xStep)(sqlite3_context*,
int,sqlite3_value**),
4716 void (*xFinal)(sqlite3_context*)
4718 SQLITE_API
int SQLITE_STDCALL sqlite3_create_function_v2(
4720 const char *zFunctionName,
4724 void (*xFunc)(sqlite3_context*,
int,sqlite3_value**),
4725 void (*xStep)(sqlite3_context*,
int,sqlite3_value**),
4726 void (*xFinal)(sqlite3_context*),
4727 void(*xDestroy)(
void*)
4736 #define SQLITE_UTF8 1 4737 #define SQLITE_UTF16LE 2 4738 #define SQLITE_UTF16BE 3 4739 #define SQLITE_UTF16 4 4740 #define SQLITE_ANY 5 4741 #define SQLITE_UTF16_ALIGNED 8 4751 #define SQLITE_DETERMINISTIC 0x800 4763 #ifndef SQLITE_OMIT_DEPRECATED 4764 SQLITE_API SQLITE_DEPRECATED
int SQLITE_STDCALL sqlite3_aggregate_count(sqlite3_context*);
4765 SQLITE_API SQLITE_DEPRECATED
int SQLITE_STDCALL sqlite3_expired(sqlite3_stmt*);
4766 SQLITE_API SQLITE_DEPRECATED
int SQLITE_STDCALL sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*);
4767 SQLITE_API SQLITE_DEPRECATED
int SQLITE_STDCALL sqlite3_global_recover(
void);
4768 SQLITE_API SQLITE_DEPRECATED
void SQLITE_STDCALL sqlite3_thread_cleanup(
void);
4769 SQLITE_API SQLITE_DEPRECATED
int SQLITE_STDCALL sqlite3_memory_alarm(
void(*)(
void*,sqlite3_int64,
int),
4770 void*,sqlite3_int64);
4819 SQLITE_API
const void *SQLITE_STDCALL sqlite3_value_blob(sqlite3_value*);
4820 SQLITE_API
int SQLITE_STDCALL sqlite3_value_bytes(sqlite3_value*);
4821 SQLITE_API
int SQLITE_STDCALL sqlite3_value_bytes16(sqlite3_value*);
4822 SQLITE_API
double SQLITE_STDCALL sqlite3_value_double(sqlite3_value*);
4823 SQLITE_API
int SQLITE_STDCALL sqlite3_value_int(sqlite3_value*);
4824 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_value_int64(sqlite3_value*);
4825 SQLITE_API
const unsigned char *SQLITE_STDCALL sqlite3_value_text(sqlite3_value*);
4826 SQLITE_API
const void *SQLITE_STDCALL sqlite3_value_text16(sqlite3_value*);
4827 SQLITE_API
const void *SQLITE_STDCALL sqlite3_value_text16le(sqlite3_value*);
4828 SQLITE_API
const void *SQLITE_STDCALL sqlite3_value_text16be(sqlite3_value*);
4829 SQLITE_API
int SQLITE_STDCALL sqlite3_value_type(sqlite3_value*);
4830 SQLITE_API
int SQLITE_STDCALL sqlite3_value_numeric_type(sqlite3_value*);
4846 SQLITE_API
unsigned int SQLITE_STDCALL sqlite3_value_subtype(sqlite3_value*);
4862 SQLITE_API sqlite3_value *SQLITE_STDCALL sqlite3_value_dup(
const sqlite3_value*);
4863 SQLITE_API
void SQLITE_STDCALL sqlite3_value_free(sqlite3_value*);
4908 SQLITE_API
void *SQLITE_STDCALL sqlite3_aggregate_context(sqlite3_context*,
int nBytes);
4923 SQLITE_API
void *SQLITE_STDCALL sqlite3_user_data(sqlite3_context*);
4935 SQLITE_API
sqlite3 *SQLITE_STDCALL sqlite3_context_db_handle(sqlite3_context*);
4989 SQLITE_API
void *SQLITE_STDCALL sqlite3_get_auxdata(sqlite3_context*,
int N);
4990 SQLITE_API
void SQLITE_STDCALL sqlite3_set_auxdata(sqlite3_context*,
int N,
void*,
void (*)(
void*));
5007 typedef void (*sqlite3_destructor_type)(
void*);
5008 #define SQLITE_STATIC ((sqlite3_destructor_type)0) 5009 #define SQLITE_TRANSIENT ((sqlite3_destructor_type)-1) 5126 SQLITE_API
void SQLITE_STDCALL sqlite3_result_blob(sqlite3_context*,
const void*,
int,
void(*)(
void*));
5127 SQLITE_API
void SQLITE_STDCALL sqlite3_result_blob64(sqlite3_context*,
const void*,
5128 sqlite3_uint64,
void(*)(
void*));
5129 SQLITE_API
void SQLITE_STDCALL sqlite3_result_double(sqlite3_context*,
double);
5130 SQLITE_API
void SQLITE_STDCALL sqlite3_result_error(sqlite3_context*,
const char*,
int);
5131 SQLITE_API
void SQLITE_STDCALL sqlite3_result_error16(sqlite3_context*,
const void*,
int);
5132 SQLITE_API
void SQLITE_STDCALL sqlite3_result_error_toobig(sqlite3_context*);
5133 SQLITE_API
void SQLITE_STDCALL sqlite3_result_error_nomem(sqlite3_context*);
5134 SQLITE_API
void SQLITE_STDCALL sqlite3_result_error_code(sqlite3_context*,
int);
5135 SQLITE_API
void SQLITE_STDCALL sqlite3_result_int(sqlite3_context*,
int);
5136 SQLITE_API
void SQLITE_STDCALL sqlite3_result_int64(sqlite3_context*, sqlite3_int64);
5137 SQLITE_API
void SQLITE_STDCALL sqlite3_result_null(sqlite3_context*);
5138 SQLITE_API
void SQLITE_STDCALL sqlite3_result_text(sqlite3_context*,
const char*,
int,
void(*)(
void*));
5139 SQLITE_API
void SQLITE_STDCALL sqlite3_result_text64(sqlite3_context*,
const char*,sqlite3_uint64,
5140 void(*)(
void*),
unsigned char encoding);
5141 SQLITE_API
void SQLITE_STDCALL sqlite3_result_text16(sqlite3_context*,
const void*,
int,
void(*)(
void*));
5142 SQLITE_API
void SQLITE_STDCALL sqlite3_result_text16le(sqlite3_context*,
const void*,
int,
void(*)(
void*));
5143 SQLITE_API
void SQLITE_STDCALL sqlite3_result_text16be(sqlite3_context*,
const void*,
int,
void(*)(
void*));
5144 SQLITE_API
void SQLITE_STDCALL sqlite3_result_value(sqlite3_context*, sqlite3_value*);
5145 SQLITE_API
void SQLITE_STDCALL sqlite3_result_zeroblob(sqlite3_context*,
int n);
5146 SQLITE_API
int SQLITE_STDCALL sqlite3_result_zeroblob64(sqlite3_context*, sqlite3_uint64 n);
5161 SQLITE_API
void SQLITE_STDCALL sqlite3_result_subtype(sqlite3_context*,
unsigned int);
5243 SQLITE_API
int SQLITE_STDCALL sqlite3_create_collation(
5248 int(*xCompare)(
void*,
int,
const void*,
int,
const void*)
5250 SQLITE_API
int SQLITE_STDCALL sqlite3_create_collation_v2(
5255 int(*xCompare)(
void*,
int,
const void*,
int,
const void*),
5256 void(*xDestroy)(
void*)
5258 SQLITE_API
int SQLITE_STDCALL sqlite3_create_collation16(
5263 int(*xCompare)(
void*,
int,
const void*,
int,
const void*)
5293 SQLITE_API
int SQLITE_STDCALL sqlite3_collation_needed(
5296 void(*)(
void*,
sqlite3*,
int eTextRep,
const char*)
5298 SQLITE_API
int SQLITE_STDCALL sqlite3_collation_needed16(
5301 void(*)(
void*,
sqlite3*,
int eTextRep,
const void*)
5304 #ifdef SQLITE_HAS_CODEC 5312 SQLITE_API
int SQLITE_STDCALL sqlite3_key(
5314 const void *pKey,
int nKey
5316 SQLITE_API
int SQLITE_STDCALL sqlite3_key_v2(
5318 const char *zDbName,
5319 const void *pKey,
int nKey
5330 SQLITE_API
int SQLITE_STDCALL sqlite3_rekey(
5332 const void *pKey,
int nKey
5334 SQLITE_API
int SQLITE_STDCALL sqlite3_rekey_v2(
5336 const char *zDbName,
5337 const void *pKey,
int nKey
5344 SQLITE_API
void SQLITE_STDCALL sqlite3_activate_see(
5345 const char *zPassPhrase
5349 #ifdef SQLITE_ENABLE_CEROD 5354 SQLITE_API
void SQLITE_STDCALL sqlite3_activate_cerod(
5355 const char *zPassPhrase
5376 SQLITE_API
int SQLITE_STDCALL sqlite3_sleep(
int);
5434 SQLITE_API
char *sqlite3_temp_directory;
5471 SQLITE_API
char *sqlite3_data_directory;
5495 SQLITE_API
int SQLITE_STDCALL sqlite3_get_autocommit(
sqlite3*);
5508 SQLITE_API
sqlite3 *SQLITE_STDCALL sqlite3_db_handle(sqlite3_stmt*);
5525 SQLITE_API
const char *SQLITE_STDCALL sqlite3_db_filename(
sqlite3 *db,
const char *zDbName);
5535 SQLITE_API
int SQLITE_STDCALL sqlite3_db_readonly(
sqlite3 *db,
const char *zDbName);
5551 SQLITE_API sqlite3_stmt *SQLITE_STDCALL sqlite3_next_stmt(
sqlite3 *pDb, sqlite3_stmt *pStmt);
5600 SQLITE_API
void *SQLITE_STDCALL sqlite3_commit_hook(
sqlite3*,
int(*)(
void*),
void*);
5601 SQLITE_API
void *SQLITE_STDCALL sqlite3_rollback_hook(
sqlite3*,
void(*)(
void *),
void*);
5652 SQLITE_API
void *SQLITE_STDCALL sqlite3_update_hook(
5654 void(*)(
void *,
int ,
char const *,
char const *,sqlite3_int64),
5692 SQLITE_API
int SQLITE_STDCALL sqlite3_enable_shared_cache(
int);
5708 SQLITE_API
int SQLITE_STDCALL sqlite3_release_memory(
int);
5722 SQLITE_API
int SQLITE_STDCALL sqlite3_db_release_memory(
sqlite3*);
5774 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_soft_heap_limit64(sqlite3_int64 N);
5785 SQLITE_API SQLITE_DEPRECATED
void SQLITE_STDCALL sqlite3_soft_heap_limit(
int N);
5855 SQLITE_API
int SQLITE_STDCALL sqlite3_table_column_metadata(
5857 const char *zDbName,
5858 const char *zTableName,
5859 const char *zColumnName,
5860 char const **pzDataType,
5861 char const **pzCollSeq,
5911 SQLITE_API
int SQLITE_STDCALL sqlite3_load_extension(
5943 SQLITE_API
int SQLITE_STDCALL sqlite3_enable_load_extension(
sqlite3 *db,
int onoff);
5981 SQLITE_API
int SQLITE_STDCALL sqlite3_auto_extension(
void(*xEntryPoint)(
void));
5993 SQLITE_API
int SQLITE_STDCALL sqlite3_cancel_auto_extension(
void(*xEntryPoint)(
void));
6001 SQLITE_API
void SQLITE_STDCALL sqlite3_reset_auto_extension(
void);
6036 struct sqlite3_module {
6038 int (*xCreate)(
sqlite3*,
void *pAux,
6039 int argc,
const char *
const*argv,
6040 sqlite3_vtab **ppVTab,
char**);
6041 int (*xConnect)(
sqlite3*,
void *pAux,
6042 int argc,
const char *
const*argv,
6043 sqlite3_vtab **ppVTab,
char**);
6044 int (*xBestIndex)(sqlite3_vtab *pVTab, sqlite3_index_info*);
6045 int (*xDisconnect)(sqlite3_vtab *pVTab);
6046 int (*xDestroy)(sqlite3_vtab *pVTab);
6047 int (*xOpen)(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor);
6048 int (*xClose)(sqlite3_vtab_cursor*);
6049 int (*xFilter)(sqlite3_vtab_cursor*,
int idxNum,
const char *idxStr,
6050 int argc, sqlite3_value **argv);
6051 int (*xNext)(sqlite3_vtab_cursor*);
6052 int (*xEof)(sqlite3_vtab_cursor*);
6053 int (*xColumn)(sqlite3_vtab_cursor*, sqlite3_context*, int);
6054 int (*xRowid)(sqlite3_vtab_cursor*, sqlite3_int64 *pRowid);
6055 int (*xUpdate)(sqlite3_vtab *, int, sqlite3_value **, sqlite3_int64 *);
6056 int (*xBegin)(sqlite3_vtab *pVTab);
6057 int (*xSync)(sqlite3_vtab *pVTab);
6058 int (*xCommit)(sqlite3_vtab *pVTab);
6059 int (*xRollback)(sqlite3_vtab *pVTab);
6060 int (*xFindFunction)(sqlite3_vtab *pVtab,
int nArg,
const char *zName,
6061 void (**pxFunc)(sqlite3_context*,int,sqlite3_value**),
6063 int (*xRename)(sqlite3_vtab *pVtab,
const char *zNew);
6066 int (*xSavepoint)(sqlite3_vtab *pVTab, int);
6067 int (*xRelease)(sqlite3_vtab *pVTab, int);
6068 int (*xRollbackTo)(sqlite3_vtab *pVTab, int);
6165 struct sqlite3_index_info {
6171 unsigned char usable;
6183 } *aConstraintUsage;
6186 int needToFreeIdxStr;
6187 int orderByConsumed;
6188 double estimatedCost;
6190 sqlite3_int64 estimatedRows;
6194 sqlite3_uint64 colUsed;
6200 #define SQLITE_INDEX_SCAN_UNIQUE 1 6210 #define SQLITE_INDEX_CONSTRAINT_EQ 2 6211 #define SQLITE_INDEX_CONSTRAINT_GT 4 6212 #define SQLITE_INDEX_CONSTRAINT_LE 8 6213 #define SQLITE_INDEX_CONSTRAINT_LT 16 6214 #define SQLITE_INDEX_CONSTRAINT_GE 32 6215 #define SQLITE_INDEX_CONSTRAINT_MATCH 64 6216 #define SQLITE_INDEX_CONSTRAINT_LIKE 65 6217 #define SQLITE_INDEX_CONSTRAINT_GLOB 66 6218 #define SQLITE_INDEX_CONSTRAINT_REGEXP 67 6246 SQLITE_API
int SQLITE_STDCALL sqlite3_create_module(
6249 const sqlite3_module *p,
6252 SQLITE_API
int SQLITE_STDCALL sqlite3_create_module_v2(
6255 const sqlite3_module *p,
6257 void(*xDestroy)(
void*)
6278 struct sqlite3_vtab {
6279 const sqlite3_module *pModule;
6302 struct sqlite3_vtab_cursor {
6303 sqlite3_vtab *pVtab;
6315 SQLITE_API
int SQLITE_STDCALL sqlite3_declare_vtab(
sqlite3*,
const char *zSQL);
6334 SQLITE_API
int SQLITE_STDCALL sqlite3_overload_function(
sqlite3*,
const char *zFuncName,
int nArg);
6358 typedef struct sqlite3_blob sqlite3_blob;
6433 SQLITE_API
int SQLITE_STDCALL sqlite3_blob_open(
6437 const char *zColumn,
6440 sqlite3_blob **ppBlob
6466 SQLITE_API
int SQLITE_STDCALL sqlite3_blob_reopen(sqlite3_blob *, sqlite3_int64);
6489 SQLITE_API
int SQLITE_STDCALL sqlite3_blob_close(sqlite3_blob *);
6505 SQLITE_API
int SQLITE_STDCALL sqlite3_blob_bytes(sqlite3_blob *);
6534 SQLITE_API
int SQLITE_STDCALL sqlite3_blob_read(sqlite3_blob *,
void *Z,
int N,
int iOffset);
6576 SQLITE_API
int SQLITE_STDCALL sqlite3_blob_write(sqlite3_blob *,
const void *z,
int n,
int iOffset);
6607 SQLITE_API sqlite3_vfs *SQLITE_STDCALL sqlite3_vfs_find(
const char *zVfsName);
6608 SQLITE_API
int SQLITE_STDCALL sqlite3_vfs_register(sqlite3_vfs*,
int makeDflt);
6609 SQLITE_API
int SQLITE_STDCALL sqlite3_vfs_unregister(sqlite3_vfs*);
6725 SQLITE_API sqlite3_mutex *SQLITE_STDCALL sqlite3_mutex_alloc(
int);
6726 SQLITE_API
void SQLITE_STDCALL sqlite3_mutex_free(sqlite3_mutex*);
6727 SQLITE_API
void SQLITE_STDCALL sqlite3_mutex_enter(sqlite3_mutex*);
6728 SQLITE_API
int SQLITE_STDCALL sqlite3_mutex_try(sqlite3_mutex*);
6729 SQLITE_API
void SQLITE_STDCALL sqlite3_mutex_leave(sqlite3_mutex*);
6797 struct sqlite3_mutex_methods {
6798 int (*xMutexInit)(void);
6799 int (*xMutexEnd)(void);
6800 sqlite3_mutex *(*xMutexAlloc)(int);
6801 void (*xMutexFree)(sqlite3_mutex *);
6802 void (*xMutexEnter)(sqlite3_mutex *);
6803 int (*xMutexTry)(sqlite3_mutex *);
6804 void (*xMutexLeave)(sqlite3_mutex *);
6805 int (*xMutexHeld)(sqlite3_mutex *);
6806 int (*xMutexNotheld)(sqlite3_mutex *);
6839 SQLITE_API
int SQLITE_STDCALL sqlite3_mutex_held(sqlite3_mutex*);
6840 SQLITE_API
int SQLITE_STDCALL sqlite3_mutex_notheld(sqlite3_mutex*);
6853 #define SQLITE_MUTEX_FAST 0 6854 #define SQLITE_MUTEX_RECURSIVE 1 6855 #define SQLITE_MUTEX_STATIC_MASTER 2 6856 #define SQLITE_MUTEX_STATIC_MEM 3 6857 #define SQLITE_MUTEX_STATIC_MEM2 4 6858 #define SQLITE_MUTEX_STATIC_OPEN 4 6859 #define SQLITE_MUTEX_STATIC_PRNG 5 6860 #define SQLITE_MUTEX_STATIC_LRU 6 6861 #define SQLITE_MUTEX_STATIC_LRU2 7 6862 #define SQLITE_MUTEX_STATIC_PMEM 7 6863 #define SQLITE_MUTEX_STATIC_APP1 8 6864 #define SQLITE_MUTEX_STATIC_APP2 9 6865 #define SQLITE_MUTEX_STATIC_APP3 10 6866 #define SQLITE_MUTEX_STATIC_VFS1 11 6867 #define SQLITE_MUTEX_STATIC_VFS2 12 6868 #define SQLITE_MUTEX_STATIC_VFS3 13 6880 SQLITE_API sqlite3_mutex *SQLITE_STDCALL sqlite3_db_mutex(
sqlite3*);
6915 SQLITE_API
int SQLITE_STDCALL sqlite3_file_control(
sqlite3*,
const char *zDbName,
int op,
void*);
6934 SQLITE_API
int SQLITE_CDECL sqlite3_test_control(
int op, ...);
6947 #define SQLITE_TESTCTRL_FIRST 5 6948 #define SQLITE_TESTCTRL_PRNG_SAVE 5 6949 #define SQLITE_TESTCTRL_PRNG_RESTORE 6 6950 #define SQLITE_TESTCTRL_PRNG_RESET 7 6951 #define SQLITE_TESTCTRL_BITVEC_TEST 8 6952 #define SQLITE_TESTCTRL_FAULT_INSTALL 9 6953 #define SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS 10 6954 #define SQLITE_TESTCTRL_PENDING_BYTE 11 6955 #define SQLITE_TESTCTRL_ASSERT 12 6956 #define SQLITE_TESTCTRL_ALWAYS 13 6957 #define SQLITE_TESTCTRL_RESERVE 14 6958 #define SQLITE_TESTCTRL_OPTIMIZATIONS 15 6959 #define SQLITE_TESTCTRL_ISKEYWORD 16 6960 #define SQLITE_TESTCTRL_SCRATCHMALLOC 17 6961 #define SQLITE_TESTCTRL_LOCALTIME_FAULT 18 6962 #define SQLITE_TESTCTRL_EXPLAIN_STMT 19 6963 #define SQLITE_TESTCTRL_NEVER_CORRUPT 20 6964 #define SQLITE_TESTCTRL_VDBE_COVERAGE 21 6965 #define SQLITE_TESTCTRL_BYTEORDER 22 6966 #define SQLITE_TESTCTRL_ISINIT 23 6967 #define SQLITE_TESTCTRL_SORTER_MMAP 24 6968 #define SQLITE_TESTCTRL_IMPOSTER 25 6969 #define SQLITE_TESTCTRL_LAST 25 6997 SQLITE_API
int SQLITE_STDCALL sqlite3_status(
int op,
int *pCurrent,
int *pHighwater,
int resetFlag);
6998 SQLITE_API
int SQLITE_STDCALL sqlite3_status64(
7000 sqlite3_int64 *pCurrent,
7001 sqlite3_int64 *pHighwater,
7089 #define SQLITE_STATUS_MEMORY_USED 0 7090 #define SQLITE_STATUS_PAGECACHE_USED 1 7091 #define SQLITE_STATUS_PAGECACHE_OVERFLOW 2 7092 #define SQLITE_STATUS_SCRATCH_USED 3 7093 #define SQLITE_STATUS_SCRATCH_OVERFLOW 4 7094 #define SQLITE_STATUS_MALLOC_SIZE 5 7095 #define SQLITE_STATUS_PARSER_STACK 6 7096 #define SQLITE_STATUS_PAGECACHE_SIZE 7 7097 #define SQLITE_STATUS_SCRATCH_SIZE 8 7098 #define SQLITE_STATUS_MALLOC_COUNT 9 7123 SQLITE_API
int SQLITE_STDCALL sqlite3_db_status(
sqlite3*,
int op,
int *pCur,
int *pHiwtr,
int resetFlg);
7227 #define SQLITE_DBSTATUS_LOOKASIDE_USED 0 7228 #define SQLITE_DBSTATUS_CACHE_USED 1 7229 #define SQLITE_DBSTATUS_SCHEMA_USED 2 7230 #define SQLITE_DBSTATUS_STMT_USED 3 7231 #define SQLITE_DBSTATUS_LOOKASIDE_HIT 4 7232 #define SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE 5 7233 #define SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL 6 7234 #define SQLITE_DBSTATUS_CACHE_HIT 7 7235 #define SQLITE_DBSTATUS_CACHE_MISS 8 7236 #define SQLITE_DBSTATUS_CACHE_WRITE 9 7237 #define SQLITE_DBSTATUS_DEFERRED_FKS 10 7238 #define SQLITE_DBSTATUS_CACHE_USED_SHARED 11 7239 #define SQLITE_DBSTATUS_MAX 11 7266 SQLITE_API
int SQLITE_STDCALL sqlite3_stmt_status(sqlite3_stmt*,
int op,
int resetFlg);
7305 #define SQLITE_STMTSTATUS_FULLSCAN_STEP 1 7306 #define SQLITE_STMTSTATUS_SORT 2 7307 #define SQLITE_STMTSTATUS_AUTOINDEX 3 7308 #define SQLITE_STMTSTATUS_VM_STEP 4 7321 typedef struct sqlite3_pcache sqlite3_pcache;
7334 struct sqlite3_pcache_page {
7499 struct sqlite3_pcache_methods2 {
7502 int (*xInit)(
void*);
7503 void (*xShutdown)(
void*);
7504 sqlite3_pcache *(*xCreate)(
int szPage,
int szExtra,
int bPurgeable);
7505 void (*xCachesize)(sqlite3_pcache*,
int nCachesize);
7506 int (*xPagecount)(sqlite3_pcache*);
7507 sqlite3_pcache_page *(*xFetch)(sqlite3_pcache*,
unsigned key,
int createFlag);
7508 void (*xUnpin)(sqlite3_pcache*, sqlite3_pcache_page*,
int discard);
7509 void (*xRekey)(sqlite3_pcache*, sqlite3_pcache_page*,
7510 unsigned oldKey,
unsigned newKey);
7511 void (*xTruncate)(sqlite3_pcache*,
unsigned iLimit);
7512 void (*xDestroy)(sqlite3_pcache*);
7513 void (*xShrink)(sqlite3_pcache*);
7522 struct sqlite3_pcache_methods {
7524 int (*xInit)(
void*);
7525 void (*xShutdown)(
void*);
7526 sqlite3_pcache *(*xCreate)(
int szPage,
int bPurgeable);
7527 void (*xCachesize)(sqlite3_pcache*,
int nCachesize);
7528 int (*xPagecount)(sqlite3_pcache*);
7529 void *(*xFetch)(sqlite3_pcache*,
unsigned key,
int createFlag);
7530 void (*xUnpin)(sqlite3_pcache*,
void*,
int discard);
7531 void (*xRekey)(sqlite3_pcache*,
void*,
unsigned oldKey,
unsigned newKey);
7532 void (*xTruncate)(sqlite3_pcache*,
unsigned iLimit);
7533 void (*xDestroy)(sqlite3_pcache*);
7735 SQLITE_API sqlite3_backup *SQLITE_STDCALL sqlite3_backup_init(
7737 const char *zDestName,
7739 const char *zSourceName
7741 SQLITE_API
int SQLITE_STDCALL sqlite3_backup_step(sqlite3_backup *p,
int nPage);
7742 SQLITE_API
int SQLITE_STDCALL sqlite3_backup_finish(sqlite3_backup *p);
7743 SQLITE_API
int SQLITE_STDCALL sqlite3_backup_remaining(sqlite3_backup *p);
7744 SQLITE_API
int SQLITE_STDCALL sqlite3_backup_pagecount(sqlite3_backup *p);
7861 SQLITE_API
int SQLITE_STDCALL sqlite3_unlock_notify(
7863 void (*xNotify)(
void **apArg,
int nArg),
7876 SQLITE_API
int SQLITE_STDCALL sqlite3_stricmp(
const char *,
const char *);
7877 SQLITE_API
int SQLITE_STDCALL sqlite3_strnicmp(
const char *,
const char *,
int);
7894 SQLITE_API
int SQLITE_STDCALL sqlite3_strglob(
const char *zGlob,
const char *zStr);
7917 SQLITE_API
int SQLITE_STDCALL sqlite3_strlike(
const char *zGlob,
const char *zStr,
unsigned int cEsc);
7940 SQLITE_API
void SQLITE_CDECL sqlite3_log(
int iErrCode,
const char *zFormat, ...);
7976 SQLITE_API
void *SQLITE_STDCALL sqlite3_wal_hook(
7978 int(*)(
void *,
sqlite3*,
const char*,
int),
8011 SQLITE_API
int SQLITE_STDCALL sqlite3_wal_autocheckpoint(
sqlite3 *db,
int N);
8033 SQLITE_API
int SQLITE_STDCALL sqlite3_wal_checkpoint(
sqlite3 *db,
const char *zDb);
8127 SQLITE_API
int SQLITE_STDCALL sqlite3_wal_checkpoint_v2(
8144 #define SQLITE_CHECKPOINT_PASSIVE 0 8145 #define SQLITE_CHECKPOINT_FULL 1 8146 #define SQLITE_CHECKPOINT_RESTART 2 8147 #define SQLITE_CHECKPOINT_TRUNCATE 3 8163 SQLITE_API
int SQLITE_CDECL sqlite3_vtab_config(
sqlite3*,
int op, ...);
8204 #define SQLITE_VTAB_CONSTRAINT_SUPPORT 1 8216 SQLITE_API
int SQLITE_STDCALL sqlite3_vtab_on_conflict(
sqlite3 *);
8230 #define SQLITE_ROLLBACK 1 8232 #define SQLITE_FAIL 3 8234 #define SQLITE_REPLACE 5 8283 #define SQLITE_SCANSTAT_NLOOP 0 8284 #define SQLITE_SCANSTAT_NVISIT 1 8285 #define SQLITE_SCANSTAT_EST 2 8286 #define SQLITE_SCANSTAT_NAME 3 8287 #define SQLITE_SCANSTAT_EXPLAIN 4 8288 #define SQLITE_SCANSTAT_SELECTID 5 8321 SQLITE_API
int SQLITE_STDCALL sqlite3_stmt_scanstatus(
8322 sqlite3_stmt *pStmt,
8337 SQLITE_API
void SQLITE_STDCALL sqlite3_stmt_scanstatus_reset(sqlite3_stmt*);
8369 SQLITE_API
int SQLITE_STDCALL sqlite3_db_cacheflush(
sqlite3*);
8449 SQLITE_API SQLITE_EXPERIMENTAL
void *SQLITE_STDCALL sqlite3_preupdate_hook(
8457 sqlite3_int64 iKey1,
8462 SQLITE_API SQLITE_EXPERIMENTAL
int SQLITE_STDCALL sqlite3_preupdate_old(
sqlite3 *,
int, sqlite3_value **);
8463 SQLITE_API SQLITE_EXPERIMENTAL
int SQLITE_STDCALL sqlite3_preupdate_count(
sqlite3 *);
8464 SQLITE_API SQLITE_EXPERIMENTAL
int SQLITE_STDCALL sqlite3_preupdate_depth(
sqlite3 *);
8465 SQLITE_API SQLITE_EXPERIMENTAL
int SQLITE_STDCALL sqlite3_preupdate_new(
sqlite3 *,
int, sqlite3_value **);
8477 SQLITE_API
int SQLITE_STDCALL sqlite3_system_errno(
sqlite3*);
8505 typedef struct sqlite3_snapshot sqlite3_snapshot;
8527 SQLITE_API SQLITE_EXPERIMENTAL
int SQLITE_STDCALL sqlite3_snapshot_get(
8529 const char *zSchema,
8530 sqlite3_snapshot **ppSnapshot
8565 SQLITE_API SQLITE_EXPERIMENTAL
int SQLITE_STDCALL sqlite3_snapshot_open(
8567 const char *zSchema,
8568 sqlite3_snapshot *pSnapshot
8582 SQLITE_API SQLITE_EXPERIMENTAL
void SQLITE_STDCALL sqlite3_snapshot_free(sqlite3_snapshot*);
8606 SQLITE_API SQLITE_EXPERIMENTAL
int SQLITE_STDCALL sqlite3_snapshot_cmp(
8607 sqlite3_snapshot *p1,
8608 sqlite3_snapshot *p2
8615 #ifdef SQLITE_OMIT_FLOATING_POINT 8638 #ifndef _SQLITE3RTREE_H_ 8639 #define _SQLITE3RTREE_H_ 8652 #ifdef SQLITE_RTREE_INT_ONLY 8653 typedef sqlite3_int64 sqlite3_rtree_dbl;
8655 typedef double sqlite3_rtree_dbl;
8664 SQLITE_API
int SQLITE_STDCALL sqlite3_rtree_geometry_callback(
8667 int (*xGeom)(sqlite3_rtree_geometry*,
int, sqlite3_rtree_dbl*,
int*),
8676 struct sqlite3_rtree_geometry {
8679 sqlite3_rtree_dbl *aParam;
8681 void (*xDelUser)(
void *);
8690 SQLITE_API
int SQLITE_STDCALL sqlite3_rtree_query_callback(
8692 const char *zQueryFunc,
8693 int (*xQueryFunc)(sqlite3_rtree_query_info*),
8695 void (*xDestructor)(
void*)
8708 struct sqlite3_rtree_query_info {
8711 sqlite3_rtree_dbl *aParam;
8713 void (*xDelUser)(
void*);
8714 sqlite3_rtree_dbl *aCoord;
8715 unsigned int *anQueue;
8719 sqlite3_int64 iRowid;
8720 sqlite3_rtree_dbl rParentScore;
8723 sqlite3_rtree_dbl rScore;
8731 #define NOT_WITHIN 0 8732 #define PARTLY_WITHIN 1 8733 #define FULLY_WITHIN 2 8745 #if !defined(__SQLITESESSION_H_) && defined(SQLITE_ENABLE_SESSION) 8746 #define __SQLITESESSION_H_ 1 8759 typedef struct sqlite3_session sqlite3_session;
8764 typedef struct sqlite3_changeset_iter sqlite3_changeset_iter;
8796 int sqlite3session_create(
8799 sqlite3_session **ppSession
8814 void sqlite3session_delete(sqlite3_session *pSession);
8834 int sqlite3session_enable(sqlite3_session *pSession,
int bEnable);
8863 int sqlite3session_indirect(sqlite3_session *pSession,
int bIndirect);
8893 int sqlite3session_attach(
8894 sqlite3_session *pSession,
8907 void sqlite3session_table_filter(
8908 sqlite3_session *pSession,
9020 int sqlite3session_changeset(
9021 sqlite3_session *pSession,
9081 int sqlite3session_diff(
9082 sqlite3_session *pSession,
9083 const char *zFromDb,
9117 int sqlite3session_patchset(
9118 sqlite3_session *pSession,
9138 int sqlite3session_isempty(sqlite3_session *pSession);
9173 int sqlite3changeset_start(
9174 sqlite3_changeset_iter **pp,
9202 int sqlite3changeset_next(sqlite3_changeset_iter *pIter);
9230 int sqlite3changeset_op(
9231 sqlite3_changeset_iter *pIter,
9263 int sqlite3changeset_pk(
9264 sqlite3_changeset_iter *pIter,
9265 unsigned char **pabPK,
9293 int sqlite3changeset_old(
9294 sqlite3_changeset_iter *pIter,
9326 int sqlite3changeset_new(
9327 sqlite3_changeset_iter *pIter,
9353 int sqlite3changeset_conflict(
9354 sqlite3_changeset_iter *pIter,
9369 int sqlite3changeset_fk_conflicts(
9370 sqlite3_changeset_iter *pIter,
9402 int sqlite3changeset_finalize(sqlite3_changeset_iter *pIter);
9432 int sqlite3changeset_invert(
9433 int nIn,
const void *pIn,
9434 int *pnOut,
void **ppOut
9461 int sqlite3changeset_concat(
9474 typedef struct sqlite3_changegroup sqlite3_changegroup;
9511 int sqlite3changegroup_new(sqlite3_changegroup **pp);
9586 int sqlite3changegroup_add(sqlite3_changegroup*,
int nData,
void *pData);
9610 int sqlite3changegroup_output(
9611 sqlite3_changegroup*,
9619 void sqlite3changegroup_delete(sqlite3_changegroup*);
9757 int sqlite3changeset_apply(
9768 sqlite3_changeset_iter *p
9828 #define SQLITE_CHANGESET_DATA 1 9829 #define SQLITE_CHANGESET_NOTFOUND 2 9830 #define SQLITE_CHANGESET_CONFLICT 3 9831 #define SQLITE_CHANGESET_CONSTRAINT 4 9832 #define SQLITE_CHANGESET_FOREIGN_KEY 5 9865 #define SQLITE_CHANGESET_OMIT 0 9866 #define SQLITE_CHANGESET_REPLACE 1 9867 #define SQLITE_CHANGESET_ABORT 2 9958 int sqlite3changeset_apply_strm(
9960 int (*xInput)(
void *pIn,
void *pData,
int *pnData),
9969 sqlite3_changeset_iter *p
9973 int sqlite3changeset_concat_strm(
9974 int (*xInputA)(
void *pIn,
void *pData,
int *pnData),
9976 int (*xInputB)(
void *pIn,
void *pData,
int *pnData),
9978 int (*xOutput)(
void *pOut,
const void *pData,
int nData),
9981 int sqlite3changeset_invert_strm(
9982 int (*xInput)(
void *pIn,
void *pData,
int *pnData),
9984 int (*xOutput)(
void *pOut,
const void *pData,
int nData),
9987 int sqlite3changeset_start_strm(
9988 sqlite3_changeset_iter **pp,
9989 int (*xInput)(
void *pIn,
void *pData,
int *pnData),
9992 int sqlite3session_changeset_strm(
9993 sqlite3_session *pSession,
9994 int (*xOutput)(
void *pOut,
const void *pData,
int nData),
9997 int sqlite3session_patchset_strm(
9998 sqlite3_session *pSession,
9999 int (*xOutput)(
void *pOut,
const void *pData,
int nData),
10002 int sqlite3changegroup_add_strm(sqlite3_changegroup*,
10003 int (*xInput)(
void *pIn,
void *pData,
int *pnData),
10006 int sqlite3changegroup_output_strm(sqlite3_changegroup*,
10007 int (*xOutput)(
void *pOut,
const void *pData,
int nData),
10059 typedef struct Fts5Context Fts5Context;
10062 typedef void (*fts5_extension_function)(
10063 const Fts5ExtensionApi *pApi,
10070 struct Fts5PhraseIter {
10071 const unsigned char *a;
10072 const unsigned char *b;
10290 struct Fts5ExtensionApi {
10293 void *(*xUserData)(Fts5Context*);
10295 int (*xColumnCount)(Fts5Context*);
10296 int (*xRowCount)(Fts5Context*, sqlite3_int64 *pnRow);
10297 int (*xColumnTotalSize)(Fts5Context*,
int iCol, sqlite3_int64 *pnToken);
10299 int (*xTokenize)(Fts5Context*,
10300 const char *pText,
int nText,
10302 int (*xToken)(
void*, int,
const char*, int, int, int)
10305 int (*xPhraseCount)(Fts5Context*);
10306 int (*xPhraseSize)(Fts5Context*,
int iPhrase);
10308 int (*xInstCount)(Fts5Context*,
int *pnInst);
10309 int (*xInst)(Fts5Context*,
int iIdx,
int *piPhrase,
int *piCol,
int *piOff);
10311 sqlite3_int64 (*xRowid)(Fts5Context*);
10312 int (*xColumnText)(Fts5Context*,
int iCol,
const char **pz,
int *pn);
10313 int (*xColumnSize)(Fts5Context*,
int iCol,
int *pnToken);
10315 int (*xQueryPhrase)(Fts5Context*,
int iPhrase,
void *pUserData,
10316 int(*)(
const Fts5ExtensionApi*,Fts5Context*,
void*)
10318 int (*xSetAuxdata)(Fts5Context*,
void *pAux, void(*xDelete)(
void*));
10319 void *(*xGetAuxdata)(Fts5Context*,
int bClear);
10321 int (*xPhraseFirst)(Fts5Context*,
int iPhrase, Fts5PhraseIter*,
int*,
int*);
10322 void (*xPhraseNext)(Fts5Context*, Fts5PhraseIter*,
int *piCol,
int *piOff);
10324 int (*xPhraseFirstColumn)(Fts5Context*,
int iPhrase, Fts5PhraseIter*,
int*);
10325 void (*xPhraseNextColumn)(Fts5Context*, Fts5PhraseIter*,
int *piCol);
10524 typedef struct Fts5Tokenizer Fts5Tokenizer;
10526 struct fts5_tokenizer {
10527 int (*xCreate)(
void*,
const char **azArg,
int nArg, Fts5Tokenizer **ppOut);
10528 void (*xDelete)(Fts5Tokenizer*);
10529 int (*xTokenize)(Fts5Tokenizer*,
10532 const char *pText,
int nText,
10536 const char *pToken,
10545 #define FTS5_TOKENIZE_QUERY 0x0001 10546 #define FTS5_TOKENIZE_PREFIX 0x0002 10547 #define FTS5_TOKENIZE_DOCUMENT 0x0004 10548 #define FTS5_TOKENIZE_AUX 0x0008 10552 #define FTS5_TOKEN_COLOCATED 0x0001 10566 int (*xCreateTokenizer)(
10570 fts5_tokenizer *pTokenizer,
10571 void (*xDestroy)(
void*)
10575 int (*xFindTokenizer)(
10579 fts5_tokenizer *pTokenizer
10583 int (*xCreateFunction)(
10587 fts5_extension_function xFunction,
10588 void (*xDestroy)(
void*)
10611 #ifdef _HAVE_SQLITE_CONFIG_H 10612 #include "config.h" 10639 #ifndef SQLITE_MAX_LENGTH 10640 # define SQLITE_MAX_LENGTH 1000000000 10660 #ifndef SQLITE_MAX_COLUMN 10661 # define SQLITE_MAX_COLUMN 2000 10671 #ifndef SQLITE_MAX_SQL_LENGTH 10672 # define SQLITE_MAX_SQL_LENGTH 1000000000 10685 #ifndef SQLITE_MAX_EXPR_DEPTH 10686 # define SQLITE_MAX_EXPR_DEPTH 1000 10697 #ifndef SQLITE_MAX_COMPOUND_SELECT 10698 # define SQLITE_MAX_COMPOUND_SELECT 500 10705 #ifndef SQLITE_MAX_VDBE_OP 10706 # define SQLITE_MAX_VDBE_OP 25000 10712 #ifndef SQLITE_MAX_FUNCTION_ARG 10713 # define SQLITE_MAX_FUNCTION_ARG 127 10725 #ifndef SQLITE_DEFAULT_CACHE_SIZE 10726 # define SQLITE_DEFAULT_CACHE_SIZE -2000 10733 #ifndef SQLITE_DEFAULT_WAL_AUTOCHECKPOINT 10734 # define SQLITE_DEFAULT_WAL_AUTOCHECKPOINT 1000 10743 #ifndef SQLITE_MAX_ATTACHED 10744 # define SQLITE_MAX_ATTACHED 10 10751 #ifndef SQLITE_MAX_VARIABLE_NUMBER 10752 # define SQLITE_MAX_VARIABLE_NUMBER 999 10766 #ifdef SQLITE_MAX_PAGE_SIZE 10767 # undef SQLITE_MAX_PAGE_SIZE 10769 #define SQLITE_MAX_PAGE_SIZE 65536 10775 #ifndef SQLITE_DEFAULT_PAGE_SIZE 10776 # define SQLITE_DEFAULT_PAGE_SIZE 4096 10778 #if SQLITE_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE 10779 # undef SQLITE_DEFAULT_PAGE_SIZE 10780 # define SQLITE_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE 10790 #ifndef SQLITE_MAX_DEFAULT_PAGE_SIZE 10791 # define SQLITE_MAX_DEFAULT_PAGE_SIZE 8192 10793 #if SQLITE_MAX_DEFAULT_PAGE_SIZE>SQLITE_MAX_PAGE_SIZE 10794 # undef SQLITE_MAX_DEFAULT_PAGE_SIZE 10795 # define SQLITE_MAX_DEFAULT_PAGE_SIZE SQLITE_MAX_PAGE_SIZE 10806 #ifndef SQLITE_MAX_PAGE_COUNT 10807 # define SQLITE_MAX_PAGE_COUNT 1073741823 10814 #ifndef SQLITE_MAX_LIKE_PATTERN_LENGTH 10815 # define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000 10825 #ifndef SQLITE_MAX_TRIGGER_DEPTH 10826 # define SQLITE_MAX_TRIGGER_DEPTH 1000 10833 #if defined(__BORLANDC__) 10844 #ifdef HAVE_STDINT_H 10845 #include <stdint.h> 10847 #ifdef HAVE_INTTYPES_H 10848 #include <inttypes.h> 10867 #if defined(__PTRDIFF_TYPE__) 10868 # define SQLITE_INT_TO_PTR(X) ((void*)(__PTRDIFF_TYPE__)(X)) 10869 # define SQLITE_PTR_TO_INT(X) ((int)(__PTRDIFF_TYPE__)(X)) 10870 #elif !defined(__GNUC__) 10871 # define SQLITE_INT_TO_PTR(X) ((void*)&((char*)0)[X]) 10872 # define SQLITE_PTR_TO_INT(X) ((int)(((char*)X)-(char*)0)) 10873 #elif defined(HAVE_STDINT_H) 10874 # define SQLITE_INT_TO_PTR(X) ((void*)(intptr_t)(X)) 10875 # define SQLITE_PTR_TO_INT(X) ((int)(intptr_t)(X)) 10877 # define SQLITE_INT_TO_PTR(X) ((void*)(X)) 10878 # define SQLITE_PTR_TO_INT(X) ((int)(X)) 10885 #if defined(__GNUC__) 10886 # define SQLITE_NOINLINE __attribute__((noinline)) 10887 #elif defined(_MSC_VER) && _MSC_VER>=1310 10888 # define SQLITE_NOINLINE __declspec(noinline) 10890 # define SQLITE_NOINLINE 10898 #if !defined(SQLITE_DISABLE_INTRINSIC) 10899 # if defined(_MSC_VER) && _MSC_VER>=1400 10900 # if !defined(_WIN32_WCE) 10901 # include <intrin.h> 10902 # pragma intrinsic(_byteswap_ushort) 10903 # pragma intrinsic(_byteswap_ulong) 10904 # pragma intrinsic(_ReadWriteBarrier) 10906 # include <cmnintrin.h> 10922 #if !defined(SQLITE_THREADSAFE) 10923 # if defined(THREADSAFE) 10924 # define SQLITE_THREADSAFE THREADSAFE 10926 # define SQLITE_THREADSAFE 1 10934 #ifndef SQLITE_POWERSAFE_OVERWRITE 10935 # define SQLITE_POWERSAFE_OVERWRITE 1 10943 #if !defined(SQLITE_DEFAULT_MEMSTATUS) 10944 # define SQLITE_DEFAULT_MEMSTATUS 1 10964 #if defined(SQLITE_SYSTEM_MALLOC) \ 10965 + defined(SQLITE_WIN32_MALLOC) \ 10966 + defined(SQLITE_ZERO_MALLOC) \ 10967 + defined(SQLITE_MEMDEBUG)>1 10968 # error "Two or more of the following compile-time configuration options\ 10969 are defined but at most one is allowed:\ 10970 SQLITE_SYSTEM_MALLOC, SQLITE_WIN32_MALLOC, SQLITE_MEMDEBUG,\ 10971 SQLITE_ZERO_MALLOC" 10973 #if defined(SQLITE_SYSTEM_MALLOC) \ 10974 + defined(SQLITE_WIN32_MALLOC) \ 10975 + defined(SQLITE_ZERO_MALLOC) \ 10976 + defined(SQLITE_MEMDEBUG)==0 10977 # define SQLITE_SYSTEM_MALLOC 1 10984 #if !defined(SQLITE_MALLOC_SOFT_LIMIT) 10985 # define SQLITE_MALLOC_SOFT_LIMIT 1024 10994 #if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) && !defined(__APPLE__) 10995 # define _XOPEN_SOURCE 600 11009 #if !defined(NDEBUG) && !defined(SQLITE_DEBUG) 11012 #if defined(NDEBUG) && defined(SQLITE_DEBUG) 11019 #if !defined(SQLITE_ENABLE_EXPLAIN_COMMENTS) && defined(SQLITE_DEBUG) 11020 # define SQLITE_ENABLE_EXPLAIN_COMMENTS 1 11037 #ifdef SQLITE_COVERAGE_TEST 11038 SQLITE_PRIVATE
void sqlite3Coverage(
int);
11039 # define testcase(X) if( X ){ sqlite3Coverage(__LINE__); } 11041 # define testcase(X) 11049 #if !defined(NDEBUG) || defined(SQLITE_COVERAGE_TEST) 11050 # define TESTONLY(X) X 11052 # define TESTONLY(X) 11064 # define VVA_ONLY(X) X 11066 # define VVA_ONLY(X) 11084 #if defined(SQLITE_COVERAGE_TEST) || defined(SQLITE_MUTATION_TEST) 11085 # define ALWAYS(X) (1) 11086 # define NEVER(X) (0) 11087 #elif !defined(NDEBUG) 11088 # define ALWAYS(X) ((X)?1:(assert(0),0)) 11089 # define NEVER(X) ((X)?(assert(0),1):0) 11091 # define ALWAYS(X) (X) 11092 # define NEVER(X) (X) 11102 #if defined(SQLITE_TEST_REALLOC_STRESS) 11103 # define ONLY_IF_REALLOC_STRESS(X) (X) 11104 #elif !defined(NDEBUG) 11105 # define ONLY_IF_REALLOC_STRESS(X) ((X)?(assert(0),1):0) 11107 # define ONLY_IF_REALLOC_STRESS(X) (0) 11113 #if defined(SQLITE_FORCE_OS_TRACE) || defined(SQLITE_TEST) || \ 11114 (defined(SQLITE_DEBUG) && SQLITE_OS_WIN) 11115 extern int sqlite3OSTrace;
11116 # define OSTRACE(X) if( sqlite3OSTrace ) sqlite3DebugPrintf X 11117 # define SQLITE_HAVE_OS_TRACE 11119 # define OSTRACE(X) 11120 # undef SQLITE_HAVE_OS_TRACE 11129 #if defined(SQLITE_HAVE_OS_TRACE) || defined(SQLITE_TEST) || \ 11130 (defined(SQLITE_DEBUG) && SQLITE_OS_WIN) 11131 # define SQLITE_NEED_ERR_NAME 11133 # undef SQLITE_NEED_ERR_NAME 11139 #ifdef SQLITE_OMIT_EXPLAIN 11140 # undef SQLITE_ENABLE_EXPLAIN_COMMENTS 11148 #define IS_BIG_INT(X) (((X)&~(i64)0xffffffff)!=0) 11157 #define likely(X) (X) 11158 #define unlikely(X) (X) 11176 #ifndef SQLITE_HASH_H 11177 #define SQLITE_HASH_H 11180 typedef struct Hash Hash;
11205 unsigned int htsize;
11206 unsigned int count;
11221 HashElem *next, *prev;
11229 SQLITE_PRIVATE
void sqlite3HashInit(Hash*);
11230 SQLITE_PRIVATE
void *sqlite3HashInsert(Hash*,
const char *pKey,
void *pData);
11231 SQLITE_PRIVATE
void *sqlite3HashFind(
const Hash*,
const char *pKey);
11232 SQLITE_PRIVATE
void sqlite3HashClear(Hash*);
11246 #define sqliteHashFirst(H) ((H)->first) 11247 #define sqliteHashNext(E) ((E)->next) 11248 #define sqliteHashData(E) ((E)->data) 11264 #define TK_EXPLAIN 2 11268 #define TK_TRANSACTION 6 11269 #define TK_DEFERRED 7 11270 #define TK_IMMEDIATE 8 11271 #define TK_EXCLUSIVE 9 11272 #define TK_COMMIT 10 11274 #define TK_ROLLBACK 12 11275 #define TK_SAVEPOINT 13 11276 #define TK_RELEASE 14 11278 #define TK_TABLE 16 11279 #define TK_CREATE 17 11282 #define TK_EXISTS 20 11287 #define TK_WITHOUT 25 11288 #define TK_COMMA 26 11292 #define TK_MATCH 30 11293 #define TK_LIKE_KW 31 11294 #define TK_BETWEEN 32 11296 #define TK_ISNULL 34 11297 #define TK_NOTNULL 35 11304 #define TK_ESCAPE 42 11305 #define TK_BITAND 43 11306 #define TK_BITOR 44 11307 #define TK_LSHIFT 45 11308 #define TK_RSHIFT 46 11310 #define TK_MINUS 48 11312 #define TK_SLASH 50 11314 #define TK_CONCAT 52 11315 #define TK_COLLATE 53 11316 #define TK_BITNOT 54 11318 #define TK_INDEXED 56 11319 #define TK_ABORT 57 11320 #define TK_ACTION 58 11321 #define TK_AFTER 59 11322 #define TK_ANALYZE 60 11324 #define TK_ATTACH 62 11325 #define TK_BEFORE 63 11327 #define TK_CASCADE 65 11329 #define TK_COLUMNKW 67 11330 #define TK_CONFLICT 68 11331 #define TK_DATABASE 69 11333 #define TK_DETACH 71 11337 #define TK_IGNORE 75 11338 #define TK_INITIALLY 76 11339 #define TK_INSTEAD 77 11343 #define TK_OFFSET 81 11344 #define TK_PRAGMA 82 11345 #define TK_RAISE 83 11346 #define TK_RECURSIVE 84 11347 #define TK_REPLACE 85 11348 #define TK_RESTRICT 86 11350 #define TK_TRIGGER 88 11351 #define TK_VACUUM 89 11353 #define TK_VIRTUAL 91 11355 #define TK_REINDEX 93 11356 #define TK_RENAME 94 11357 #define TK_CTIME_KW 95 11359 #define TK_STRING 97 11360 #define TK_JOIN_KW 98 11361 #define TK_CONSTRAINT 99 11362 #define TK_DEFAULT 100 11363 #define TK_NULL 101 11364 #define TK_PRIMARY 102 11365 #define TK_UNIQUE 103 11366 #define TK_CHECK 104 11367 #define TK_REFERENCES 105 11368 #define TK_AUTOINCR 106 11370 #define TK_INSERT 108 11371 #define TK_DELETE 109 11372 #define TK_UPDATE 110 11374 #define TK_DEFERRABLE 112 11375 #define TK_FOREIGN 113 11376 #define TK_DROP 114 11377 #define TK_UNION 115 11379 #define TK_EXCEPT 117 11380 #define TK_INTERSECT 118 11381 #define TK_SELECT 119 11382 #define TK_VALUES 120 11383 #define TK_DISTINCT 121 11385 #define TK_FROM 123 11386 #define TK_JOIN 124 11387 #define TK_USING 125 11388 #define TK_ORDER 126 11389 #define TK_GROUP 127 11390 #define TK_HAVING 128 11391 #define TK_LIMIT 129 11392 #define TK_WHERE 130 11393 #define TK_INTO 131 11394 #define TK_INTEGER 132 11395 #define TK_FLOAT 133 11396 #define TK_BLOB 134 11397 #define TK_VARIABLE 135 11398 #define TK_CASE 136 11399 #define TK_WHEN 137 11400 #define TK_THEN 138 11401 #define TK_ELSE 139 11402 #define TK_INDEX 140 11403 #define TK_ALTER 141 11405 #define TK_TO_TEXT 143 11406 #define TK_TO_BLOB 144 11407 #define TK_TO_NUMERIC 145 11408 #define TK_TO_INT 146 11409 #define TK_TO_REAL 147 11410 #define TK_ISNOT 148 11411 #define TK_END_OF_FILE 149 11412 #define TK_UNCLOSED_STRING 150 11413 #define TK_FUNCTION 151 11414 #define TK_COLUMN 152 11415 #define TK_AGG_FUNCTION 153 11416 #define TK_AGG_COLUMN 154 11417 #define TK_UMINUS 155 11418 #define TK_UPLUS 156 11419 #define TK_REGISTER 157 11420 #define TK_ASTERISK 158 11421 #define TK_SPAN 159 11422 #define TK_SPACE 160 11423 #define TK_ILLEGAL 161 11426 #define TKFLG_MASK 0xff 11430 #define TKFLG_DONTFOLD 0x100 11435 #include <stdlib.h> 11436 #include <string.h> 11437 #include <assert.h> 11438 #include <stddef.h> 11444 #ifdef SQLITE_OMIT_FLOATING_POINT 11445 # define double sqlite_int64 11446 # define float sqlite_int64 11447 # define LONGDOUBLE_TYPE sqlite_int64 11448 # ifndef SQLITE_BIG_DBL 11449 # define SQLITE_BIG_DBL (((sqlite3_int64)1)<<50) 11451 # define SQLITE_OMIT_DATETIME_FUNCS 1 11452 # define SQLITE_OMIT_TRACE 1 11453 # undef SQLITE_MIXED_ENDIAN_64BIT_FLOAT 11454 # undef SQLITE_HAVE_ISNAN 11456 #ifndef SQLITE_BIG_DBL 11457 # define SQLITE_BIG_DBL (1e99) 11465 #ifdef SQLITE_OMIT_TEMPDB 11466 #define OMIT_TEMPDB 1 11468 #define OMIT_TEMPDB 0 11477 #define SQLITE_MAX_FILE_FORMAT 4 11478 #ifndef SQLITE_DEFAULT_FILE_FORMAT 11479 # define SQLITE_DEFAULT_FILE_FORMAT 4 11486 #ifndef SQLITE_DEFAULT_RECURSIVE_TRIGGERS 11487 # define SQLITE_DEFAULT_RECURSIVE_TRIGGERS 0 11494 #ifndef SQLITE_TEMP_STORE 11495 # define SQLITE_TEMP_STORE 1 11496 # define SQLITE_TEMP_STORE_xc 1 11504 #if SQLITE_TEMP_STORE==3 || SQLITE_THREADSAFE==0 11505 # undef SQLITE_MAX_WORKER_THREADS 11506 # define SQLITE_MAX_WORKER_THREADS 0 11508 #ifndef SQLITE_MAX_WORKER_THREADS 11509 # define SQLITE_MAX_WORKER_THREADS 8 11511 #ifndef SQLITE_DEFAULT_WORKER_THREADS 11512 # define SQLITE_DEFAULT_WORKER_THREADS 0 11514 #if SQLITE_DEFAULT_WORKER_THREADS>SQLITE_MAX_WORKER_THREADS 11515 # undef SQLITE_MAX_WORKER_THREADS 11516 # define SQLITE_MAX_WORKER_THREADS SQLITE_DEFAULT_WORKER_THREADS 11525 #ifndef SQLITE_DEFAULT_PCACHE_INITSZ 11526 # define SQLITE_DEFAULT_PCACHE_INITSZ 100 11534 #define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD)) 11541 # define MIN(A,B) ((A)<(B)?(A):(B)) 11544 # define MAX(A,B) ((A)>(B)?(A):(B)) 11550 #define SWAP(TYPE,A,B) {TYPE t=A; A=B; B=t;} 11557 # define SQLITE_EBCDIC 1 11559 # define SQLITE_ASCII 1 11569 #ifndef UINT32_TYPE 11570 # ifdef HAVE_UINT32_T 11571 # define UINT32_TYPE uint32_t 11573 # define UINT32_TYPE unsigned int 11576 #ifndef UINT16_TYPE 11577 # ifdef HAVE_UINT16_T 11578 # define UINT16_TYPE uint16_t 11580 # define UINT16_TYPE unsigned short int 11584 # ifdef HAVE_INT16_T 11585 # define INT16_TYPE int16_t 11587 # define INT16_TYPE short int 11591 # ifdef HAVE_UINT8_T 11592 # define UINT8_TYPE uint8_t 11594 # define UINT8_TYPE unsigned char 11598 # ifdef HAVE_INT8_T 11599 # define INT8_TYPE int8_t 11601 # define INT8_TYPE signed char 11604 #ifndef LONGDOUBLE_TYPE 11605 # define LONGDOUBLE_TYPE long double 11607 typedef sqlite_int64 i64;
11608 typedef sqlite_uint64 u64;
11609 typedef UINT32_TYPE u32;
11610 typedef UINT16_TYPE u16;
11611 typedef INT16_TYPE i16;
11612 typedef UINT8_TYPE u8;
11613 typedef INT8_TYPE i8;
11621 #define SQLITE_MAX_U32 ((((u64)1)<<32)-1) 11629 #ifdef SQLITE_64BIT_STATS 11630 typedef u64 tRowcnt;
11632 typedef u32 tRowcnt;
11658 typedef INT16_TYPE LogEst;
11663 #ifndef SQLITE_PTRSIZE 11664 # if defined(__SIZEOF_POINTER__) 11665 # define SQLITE_PTRSIZE __SIZEOF_POINTER__ 11666 # elif defined(i386) || defined(__i386__) || defined(_M_IX86) || \ 11667 defined(_M_ARM) || defined(__arm__) || defined(__x86) 11668 # define SQLITE_PTRSIZE 4 11670 # define SQLITE_PTRSIZE 8 11676 #if defined(HAVE_STDINT_H) 11677 typedef uintptr_t uptr;
11678 #elif SQLITE_PTRSIZE==4 11692 #define SQLITE_WITHIN(P,S,E) (((uptr)(P)>=(uptr)(S))&&((uptr)(P)<(uptr)(E))) 11704 #if (defined(i386) || defined(__i386__) || defined(_M_IX86) || \ 11705 defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) || \ 11706 defined(_M_AMD64) || defined(_M_ARM) || defined(__x86) || \ 11707 defined(__arm__)) && !defined(SQLITE_RUNTIME_BYTEORDER) 11708 # define SQLITE_BYTEORDER 1234 11709 # define SQLITE_BIGENDIAN 0 11710 # define SQLITE_LITTLEENDIAN 1 11711 # define SQLITE_UTF16NATIVE SQLITE_UTF16LE 11713 #if (defined(sparc) || defined(__ppc__)) \ 11714 && !defined(SQLITE_RUNTIME_BYTEORDER) 11715 # define SQLITE_BYTEORDER 4321 11716 # define SQLITE_BIGENDIAN 1 11717 # define SQLITE_LITTLEENDIAN 0 11718 # define SQLITE_UTF16NATIVE SQLITE_UTF16BE 11720 #if !defined(SQLITE_BYTEORDER) 11721 # ifdef SQLITE_AMALGAMATION 11722 const int sqlite3one = 1;
11724 extern const int sqlite3one;
11726 # define SQLITE_BYTEORDER 0 11727 # define SQLITE_BIGENDIAN (*(char *)(&sqlite3one)==0) 11728 # define SQLITE_LITTLEENDIAN (*(char *)(&sqlite3one)==1) 11729 # define SQLITE_UTF16NATIVE (SQLITE_BIGENDIAN?SQLITE_UTF16BE:SQLITE_UTF16LE) 11737 #define LARGEST_INT64 (0xffffffff|(((i64)0x7fffffff)<<32)) 11738 #define SMALLEST_INT64 (((i64)-1) - LARGEST_INT64) 11744 #define ROUND8(x) (((x)+7)&~7) 11749 #define ROUNDDOWN8(x) ((x)&~7) 11760 #ifdef SQLITE_4_BYTE_ALIGNED_MALLOC 11761 # define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&3)==0) 11763 # define EIGHT_BYTE_ALIGNMENT(X) ((((char*)(X) - (char*)0)&7)==0) 11769 #if defined(__OpenBSD__) || defined(__QNXNTO__) 11770 # undef SQLITE_MAX_MMAP_SIZE 11771 # define SQLITE_MAX_MMAP_SIZE 0 11778 # include <TargetConditionals.h> 11780 #ifndef SQLITE_MAX_MMAP_SIZE 11781 # if defined(__linux__) \ 11782 || defined(_WIN32) \ 11783 || (defined(__APPLE__) && defined(__MACH__)) \ 11784 || defined(__sun) \ 11785 || defined(__FreeBSD__) \ 11786 || defined(__DragonFly__) 11787 # define SQLITE_MAX_MMAP_SIZE 0x7fff0000 11789 # define SQLITE_MAX_MMAP_SIZE 0 11791 # define SQLITE_MAX_MMAP_SIZE_xc 1 11799 #ifndef SQLITE_DEFAULT_MMAP_SIZE 11800 # define SQLITE_DEFAULT_MMAP_SIZE 0 11801 # define SQLITE_DEFAULT_MMAP_SIZE_xc 1 11803 #if SQLITE_DEFAULT_MMAP_SIZE>SQLITE_MAX_MMAP_SIZE 11804 # undef SQLITE_DEFAULT_MMAP_SIZE 11805 # define SQLITE_DEFAULT_MMAP_SIZE SQLITE_MAX_MMAP_SIZE 11813 #ifdef SQLITE_ENABLE_STAT4 11814 # undef SQLITE_ENABLE_STAT3 11815 # define SQLITE_ENABLE_STAT3_OR_STAT4 1 11816 #elif SQLITE_ENABLE_STAT3 11817 # define SQLITE_ENABLE_STAT3_OR_STAT4 1 11818 #elif SQLITE_ENABLE_STAT3_OR_STAT4 11819 # undef SQLITE_ENABLE_STAT3_OR_STAT4 11826 #if defined(SQLITE_DEBUG) || defined(SQLITE_ENABLE_SELECTTRACE) 11827 # define SELECTTRACE_ENABLED 1 11829 # define SELECTTRACE_ENABLED 0 11842 struct BusyHandler {
11843 int (*xFunc)(
void *,int);
11853 #define MASTER_NAME "sqlite_master" 11854 #define TEMP_MASTER_NAME "sqlite_temp_master" 11859 #define MASTER_ROOT 1 11864 #define SCHEMA_TABLE(x) ((!OMIT_TEMPDB)&&(x==1)?TEMP_MASTER_NAME:MASTER_NAME) 11870 #define ArraySize(X) ((int)(sizeof(X)/sizeof(X[0]))) 11875 #define IsPowerOfTwo(X) (((X)&((X)-1))==0) 11885 #define SQLITE_DYNAMIC ((sqlite3_destructor_type)sqlite3MallocSize) 11901 #ifdef SQLITE_OMIT_WSD 11902 #define SQLITE_WSD const 11903 #define GLOBAL(t,v) (*(t*)sqlite3_wsd_find((void*)&(v), sizeof(v))) 11904 #define sqlite3GlobalConfig GLOBAL(struct Sqlite3Config, sqlite3Config) 11905 SQLITE_API
int SQLITE_STDCALL sqlite3_wsd_init(
int N,
int J);
11906 SQLITE_API
void *SQLITE_STDCALL sqlite3_wsd_find(
void *K,
int L);
11909 #define GLOBAL(t,v) v 11910 #define sqlite3GlobalConfig sqlite3Config 11929 #define UNUSED_PARAMETER(x) (void)(x) 11930 #define UNUSED_PARAMETER2(x,y) UNUSED_PARAMETER(x),UNUSED_PARAMETER(y) 11935 typedef struct AggInfo AggInfo;
11938 typedef struct Bitvec Bitvec;
11939 typedef struct CollSeq CollSeq;
11940 typedef struct Column Column;
11941 typedef struct Db Db;
11942 typedef struct Schema Schema;
11943 typedef struct Expr Expr;
11946 typedef struct FKey FKey;
11948 typedef struct FuncDef FuncDef;
11950 typedef struct IdList IdList;
11951 typedef struct Index Index;
11953 typedef struct KeyClass KeyClass;
11954 typedef struct KeyInfo KeyInfo;
11957 typedef struct Module Module;
11959 typedef struct Parse Parse;
11962 typedef struct RowSet RowSet;
11964 typedef struct Select Select;
11967 typedef struct SrcList SrcList;
11969 typedef struct Table Table;
11971 typedef struct Token Token;
11972 typedef struct TreeView TreeView;
11973 typedef struct Trigger Trigger;
11977 typedef struct VTable VTable;
11978 typedef struct VtabCtx VtabCtx;
11979 typedef struct Walker Walker;
11981 typedef struct With With;
12005 #ifndef SQLITE_BTREE_H 12006 #define SQLITE_BTREE_H 12011 #define SQLITE_N_BTREE_META 16 12017 #ifndef SQLITE_DEFAULT_AUTOVACUUM 12018 #define SQLITE_DEFAULT_AUTOVACUUM 0 12021 #define BTREE_AUTOVACUUM_NONE 0 12022 #define BTREE_AUTOVACUUM_FULL 1 12023 #define BTREE_AUTOVACUUM_INCR 2 12028 typedef struct Btree Btree;
12034 SQLITE_PRIVATE
int sqlite3BtreeOpen(
12036 const char *zFilename,
12049 #define BTREE_OMIT_JOURNAL 1 12050 #define BTREE_MEMORY 2 12051 #define BTREE_SINGLE 4 12052 #define BTREE_UNORDERED 8 12054 SQLITE_PRIVATE
int sqlite3BtreeClose(Btree*);
12055 SQLITE_PRIVATE
int sqlite3BtreeSetCacheSize(Btree*,
int);
12056 SQLITE_PRIVATE
int sqlite3BtreeSetSpillSize(Btree*,
int);
12057 #if SQLITE_MAX_MMAP_SIZE>0 12058 SQLITE_PRIVATE
int sqlite3BtreeSetMmapLimit(Btree*,sqlite3_int64);
12060 SQLITE_PRIVATE
int sqlite3BtreeSetPagerFlags(Btree*,
unsigned);
12061 SQLITE_PRIVATE
int sqlite3BtreeSetPageSize(Btree *p,
int nPagesize,
int nReserve,
int eFix);
12062 SQLITE_PRIVATE
int sqlite3BtreeGetPageSize(Btree*);
12063 SQLITE_PRIVATE
int sqlite3BtreeMaxPageCount(Btree*,
int);
12064 SQLITE_PRIVATE u32 sqlite3BtreeLastPage(Btree*);
12065 SQLITE_PRIVATE
int sqlite3BtreeSecureDelete(Btree*,
int);
12066 SQLITE_PRIVATE
int sqlite3BtreeGetOptimalReserve(Btree*);
12067 SQLITE_PRIVATE
int sqlite3BtreeGetReserveNoMutex(Btree *p);
12068 SQLITE_PRIVATE
int sqlite3BtreeSetAutoVacuum(Btree *,
int);
12069 SQLITE_PRIVATE
int sqlite3BtreeGetAutoVacuum(Btree *);
12070 SQLITE_PRIVATE
int sqlite3BtreeBeginTrans(Btree*,
int);
12071 SQLITE_PRIVATE
int sqlite3BtreeCommitPhaseOne(Btree*,
const char *zMaster);
12072 SQLITE_PRIVATE
int sqlite3BtreeCommitPhaseTwo(Btree*,
int);
12073 SQLITE_PRIVATE
int sqlite3BtreeCommit(Btree*);
12074 SQLITE_PRIVATE
int sqlite3BtreeRollback(Btree*,
int,
int);
12075 SQLITE_PRIVATE
int sqlite3BtreeBeginStmt(Btree*,
int);
12076 SQLITE_PRIVATE
int sqlite3BtreeCreateTable(Btree*,
int*,
int flags);
12077 SQLITE_PRIVATE
int sqlite3BtreeIsInTrans(Btree*);
12078 SQLITE_PRIVATE
int sqlite3BtreeIsInReadTrans(Btree*);
12079 SQLITE_PRIVATE
int sqlite3BtreeIsInBackup(Btree*);
12080 SQLITE_PRIVATE
void *sqlite3BtreeSchema(Btree *,
int,
void(*)(
void *));
12081 SQLITE_PRIVATE
int sqlite3BtreeSchemaLocked(Btree *pBtree);
12082 SQLITE_PRIVATE
int sqlite3BtreeLockTable(Btree *pBtree,
int iTab, u8 isWriteLock);
12083 SQLITE_PRIVATE
int sqlite3BtreeSavepoint(Btree *,
int,
int);
12085 SQLITE_PRIVATE
const char *sqlite3BtreeGetFilename(Btree *);
12086 SQLITE_PRIVATE
const char *sqlite3BtreeGetJournalname(Btree *);
12087 SQLITE_PRIVATE
int sqlite3BtreeCopyFile(Btree *, Btree *);
12089 SQLITE_PRIVATE
int sqlite3BtreeIncrVacuum(Btree *);
12101 #define BTREE_INTKEY 1 12102 #define BTREE_BLOBKEY 2 12104 SQLITE_PRIVATE
int sqlite3BtreeDropTable(Btree*,
int,
int*);
12105 SQLITE_PRIVATE
int sqlite3BtreeClearTable(Btree*,
int,
int*);
12106 SQLITE_PRIVATE
int sqlite3BtreeClearTableOfCursor(BtCursor*);
12107 SQLITE_PRIVATE
int sqlite3BtreeTripAllCursors(Btree*,
int,
int);
12109 SQLITE_PRIVATE
void sqlite3BtreeGetMeta(Btree *pBtree,
int idx, u32 *pValue);
12110 SQLITE_PRIVATE
int sqlite3BtreeUpdateMeta(Btree*,
int idx, u32 value);
12112 SQLITE_PRIVATE
int sqlite3BtreeNewDb(Btree *p);
12131 #define BTREE_FREE_PAGE_COUNT 0 12132 #define BTREE_SCHEMA_VERSION 1 12133 #define BTREE_FILE_FORMAT 2 12134 #define BTREE_DEFAULT_CACHE_SIZE 3 12135 #define BTREE_LARGEST_ROOT_PAGE 4 12136 #define BTREE_TEXT_ENCODING 5 12137 #define BTREE_USER_VERSION 6 12138 #define BTREE_INCR_VACUUM 7 12139 #define BTREE_APPLICATION_ID 8 12140 #define BTREE_DATA_VERSION 15 12169 #define BTREE_HINT_RANGE 0 12184 #define BTREE_BULKLOAD 0x00000001 12185 #define BTREE_SEEK_EQ 0x00000002 12210 #define BTREE_WRCSR 0x00000004 12211 #define BTREE_FORDELETE 0x00000008 12213 SQLITE_PRIVATE
int sqlite3BtreeCursor(
12220 SQLITE_PRIVATE
int sqlite3BtreeCursorSize(
void);
12221 SQLITE_PRIVATE
void sqlite3BtreeCursorZero(BtCursor*);
12222 SQLITE_PRIVATE
void sqlite3BtreeCursorHintFlags(BtCursor*,
unsigned);
12223 #ifdef SQLITE_ENABLE_CURSOR_HINTS 12224 SQLITE_PRIVATE
void sqlite3BtreeCursorHint(BtCursor*,
int, ...);
12227 SQLITE_PRIVATE
int sqlite3BtreeCloseCursor(BtCursor*);
12228 SQLITE_PRIVATE
int sqlite3BtreeMovetoUnpacked(
12230 UnpackedRecord *pUnKey,
12235 SQLITE_PRIVATE
int sqlite3BtreeCursorHasMoved(BtCursor*);
12236 SQLITE_PRIVATE
int sqlite3BtreeCursorRestore(BtCursor*,
int*);
12237 SQLITE_PRIVATE
int sqlite3BtreeDelete(BtCursor*, u8 flags);
12240 #define BTREE_SAVEPOSITION 0x02 12241 #define BTREE_AUXDELETE 0x04 12261 struct BtreePayload {
12263 sqlite3_int64 nKey;
12269 SQLITE_PRIVATE
int sqlite3BtreeInsert(BtCursor*,
const BtreePayload *pPayload,
12270 int bias,
int seekResult);
12271 SQLITE_PRIVATE
int sqlite3BtreeFirst(BtCursor*,
int *pRes);
12272 SQLITE_PRIVATE
int sqlite3BtreeLast(BtCursor*,
int *pRes);
12273 SQLITE_PRIVATE
int sqlite3BtreeNext(BtCursor*,
int *pRes);
12274 SQLITE_PRIVATE
int sqlite3BtreeEof(BtCursor*);
12275 SQLITE_PRIVATE
int sqlite3BtreePrevious(BtCursor*,
int *pRes);
12276 SQLITE_PRIVATE i64 sqlite3BtreeIntegerKey(BtCursor*);
12277 SQLITE_PRIVATE
int sqlite3BtreeKey(BtCursor*, u32 offset, u32 amt,
void*);
12278 SQLITE_PRIVATE
const void *sqlite3BtreePayloadFetch(BtCursor*, u32 *pAmt);
12279 SQLITE_PRIVATE u32 sqlite3BtreePayloadSize(BtCursor*);
12280 SQLITE_PRIVATE
int sqlite3BtreeData(BtCursor*, u32 offset, u32 amt,
void*);
12282 SQLITE_PRIVATE
char *sqlite3BtreeIntegrityCheck(Btree*,
int *aRoot,
int nRoot,
int,
int*);
12283 SQLITE_PRIVATE
struct Pager *sqlite3BtreePager(Btree*);
12285 SQLITE_PRIVATE
int sqlite3BtreePutData(BtCursor*, u32 offset, u32 amt,
void*);
12286 SQLITE_PRIVATE
void sqlite3BtreeIncrblobCursor(BtCursor *);
12287 SQLITE_PRIVATE
void sqlite3BtreeClearCursor(BtCursor *);
12288 SQLITE_PRIVATE
int sqlite3BtreeSetVersion(Btree *pBt,
int iVersion);
12289 SQLITE_PRIVATE
int sqlite3BtreeCursorHasHint(BtCursor*,
unsigned int mask);
12290 SQLITE_PRIVATE
int sqlite3BtreeIsReadonly(Btree *pBt);
12291 SQLITE_PRIVATE
int sqlite3HeaderSizeBtree(
void);
12294 SQLITE_PRIVATE
int sqlite3BtreeCursorIsValid(BtCursor*);
12297 #ifndef SQLITE_OMIT_BTREECOUNT 12298 SQLITE_PRIVATE
int sqlite3BtreeCount(BtCursor *, i64 *);
12302 SQLITE_PRIVATE
int sqlite3BtreeCursorInfo(BtCursor*,
int*,
int);
12303 SQLITE_PRIVATE
void sqlite3BtreeCursorList(Btree*);
12306 #ifndef SQLITE_OMIT_WAL 12307 SQLITE_PRIVATE
int sqlite3BtreeCheckpoint(Btree*,
int,
int *,
int *);
12315 #ifndef SQLITE_OMIT_SHARED_CACHE 12316 SQLITE_PRIVATE
void sqlite3BtreeEnter(Btree*);
12317 SQLITE_PRIVATE
void sqlite3BtreeEnterAll(
sqlite3*);
12318 SQLITE_PRIVATE
int sqlite3BtreeSharable(Btree*);
12319 SQLITE_PRIVATE
void sqlite3BtreeEnterCursor(BtCursor*);
12320 SQLITE_PRIVATE
int sqlite3BtreeConnectionCount(Btree*);
12322 # define sqlite3BtreeEnter(X) 12323 # define sqlite3BtreeEnterAll(X) 12324 # define sqlite3BtreeSharable(X) 0 12325 # define sqlite3BtreeEnterCursor(X) 12326 # define sqlite3BtreeConnectionCount(X) 1 12329 #if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE 12330 SQLITE_PRIVATE
void sqlite3BtreeLeave(Btree*);
12331 SQLITE_PRIVATE
void sqlite3BtreeLeaveCursor(BtCursor*);
12332 SQLITE_PRIVATE
void sqlite3BtreeLeaveAll(
sqlite3*);
12335 SQLITE_PRIVATE
int sqlite3BtreeHoldsMutex(Btree*);
12336 SQLITE_PRIVATE
int sqlite3BtreeHoldsAllMutexes(
sqlite3*);
12337 SQLITE_PRIVATE
int sqlite3SchemaMutexHeld(
sqlite3*,
int,Schema*);
12341 # define sqlite3BtreeLeave(X) 12342 # define sqlite3BtreeLeaveCursor(X) 12343 # define sqlite3BtreeLeaveAll(X) 12345 # define sqlite3BtreeHoldsMutex(X) 1 12346 # define sqlite3BtreeHoldsAllMutexes(X) 1 12347 # define sqlite3SchemaMutexHeld(X,Y,Z) 1 12374 #ifndef SQLITE_VDBE_H 12375 #define SQLITE_VDBE_H 12383 typedef struct Vdbe Vdbe;
12389 typedef struct Mem Mem;
12399 signed char p4type;
12418 SubProgram *pProgram;
12420 #ifdef SQLITE_ENABLE_CURSOR_HINTS 12423 int (*xAdvance)(BtCursor *,
int *);
12425 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS 12428 #ifdef VDBE_PROFILE 12432 #ifdef SQLITE_VDBE_COVERAGE 12436 typedef struct VdbeOp VdbeOp;
12442 struct SubProgram {
12467 #define P4_NOTUSED 0 12468 #define P4_DYNAMIC (-1) 12469 #define P4_STATIC (-2) 12470 #define P4_COLLSEQ (-4) 12471 #define P4_FUNCDEF (-5) 12472 #define P4_KEYINFO (-6) 12473 #define P4_EXPR (-7) 12474 #define P4_MEM (-8) 12475 #define P4_TRANSIENT 0 12476 #define P4_VTAB (-10) 12477 #define P4_MPRINTF (-11) 12478 #define P4_REAL (-12) 12479 #define P4_INT64 (-13) 12480 #define P4_INT32 (-14) 12481 #define P4_INTARRAY (-15) 12482 #define P4_SUBPROGRAM (-18) 12483 #define P4_ADVANCE (-19) 12484 #define P4_TABLE (-20) 12485 #define P4_FUNCCTX (-21) 12488 #define P5_ConstraintNotNull 1 12489 #define P5_ConstraintUnique 2 12490 #define P5_ConstraintCheck 3 12491 #define P5_ConstraintFK 4 12497 #define COLNAME_NAME 0 12498 #define COLNAME_DECLTYPE 1 12499 #define COLNAME_DATABASE 2 12500 #define COLNAME_TABLE 3 12501 #define COLNAME_COLUMN 4 12502 #ifdef SQLITE_ENABLE_COLUMN_METADATA 12503 # define COLNAME_N 5 12505 # ifdef SQLITE_OMIT_DECLTYPE 12506 # define COLNAME_N 1 12508 # define COLNAME_N 2 12518 #define ADDR(X) (-1-(X)) 12528 #define OP_Savepoint 0 12529 #define OP_AutoCommit 1 12530 #define OP_Transaction 2 12531 #define OP_SorterNext 3 12532 #define OP_PrevIfOpen 4 12533 #define OP_NextIfOpen 5 12536 #define OP_Checkpoint 8 12537 #define OP_JournalMode 9 12538 #define OP_Vacuum 10 12539 #define OP_VFilter 11 12540 #define OP_VUpdate 12 12542 #define OP_Gosub 14 12543 #define OP_InitCoroutine 15 12544 #define OP_Yield 16 12545 #define OP_MustBeInt 17 12550 #define OP_IfNot 22 12551 #define OP_SeekLT 23 12552 #define OP_SeekLE 24 12553 #define OP_SeekGE 25 12554 #define OP_SeekGT 26 12557 #define OP_NoConflict 29 12558 #define OP_NotFound 30 12559 #define OP_Found 31 12560 #define OP_SeekRowid 32 12561 #define OP_NotExists 33 12562 #define OP_IsNull 34 12563 #define OP_NotNull 35 12571 #define OP_BitAnd 43 12572 #define OP_BitOr 44 12573 #define OP_ShiftLeft 45 12574 #define OP_ShiftRight 46 12576 #define OP_Subtract 48 12577 #define OP_Multiply 49 12578 #define OP_Divide 50 12579 #define OP_Remainder 51 12580 #define OP_Concat 52 12581 #define OP_SorterSort 53 12582 #define OP_BitNot 54 12584 #define OP_Rewind 56 12585 #define OP_IdxLE 57 12586 #define OP_IdxGT 58 12587 #define OP_IdxLT 59 12588 #define OP_IdxGE 60 12589 #define OP_RowSetRead 61 12590 #define OP_RowSetTest 62 12591 #define OP_Program 63 12592 #define OP_FkIfZero 64 12593 #define OP_IfPos 65 12594 #define OP_IfNotZero 66 12595 #define OP_DecrJumpZero 67 12596 #define OP_IncrVacuum 68 12597 #define OP_VNext 69 12599 #define OP_Return 71 12600 #define OP_EndCoroutine 72 12601 #define OP_HaltIfNull 73 12603 #define OP_Integer 75 12604 #define OP_Int64 76 12605 #define OP_String 77 12607 #define OP_SoftNull 79 12609 #define OP_Variable 81 12612 #define OP_SCopy 84 12613 #define OP_IntCopy 85 12614 #define OP_ResultRow 86 12615 #define OP_CollSeq 87 12616 #define OP_Function0 88 12617 #define OP_Function 89 12618 #define OP_AddImm 90 12619 #define OP_RealAffinity 91 12621 #define OP_Permutation 93 12622 #define OP_Compare 94 12623 #define OP_Column 95 12624 #define OP_Affinity 96 12625 #define OP_String8 97 12626 #define OP_MakeRecord 98 12627 #define OP_Count 99 12628 #define OP_ReadCookie 100 12629 #define OP_SetCookie 101 12630 #define OP_ReopenIdx 102 12631 #define OP_OpenRead 103 12632 #define OP_OpenWrite 104 12633 #define OP_OpenAutoindex 105 12634 #define OP_OpenEphemeral 106 12635 #define OP_SorterOpen 107 12636 #define OP_SequenceTest 108 12637 #define OP_OpenPseudo 109 12638 #define OP_Close 110 12639 #define OP_ColumnsUsed 111 12640 #define OP_Sequence 112 12641 #define OP_NewRowid 113 12642 #define OP_Insert 114 12643 #define OP_InsertInt 115 12644 #define OP_Delete 116 12645 #define OP_ResetCount 117 12646 #define OP_SorterCompare 118 12647 #define OP_SorterData 119 12648 #define OP_RowKey 120 12649 #define OP_RowData 121 12650 #define OP_Rowid 122 12651 #define OP_NullRow 123 12652 #define OP_SorterInsert 124 12653 #define OP_IdxInsert 125 12654 #define OP_IdxDelete 126 12655 #define OP_Seek 127 12656 #define OP_IdxRowid 128 12657 #define OP_Destroy 129 12658 #define OP_Clear 130 12659 #define OP_ResetSorter 131 12660 #define OP_CreateIndex 132 12661 #define OP_Real 133 12662 #define OP_CreateTable 134 12663 #define OP_ParseSchema 135 12664 #define OP_LoadAnalysis 136 12665 #define OP_DropTable 137 12666 #define OP_DropIndex 138 12667 #define OP_DropTrigger 139 12668 #define OP_IntegrityCk 140 12669 #define OP_RowSetAdd 141 12670 #define OP_Param 142 12671 #define OP_FkCounter 143 12672 #define OP_MemMax 144 12673 #define OP_OffsetLimit 145 12674 #define OP_AggStep0 146 12675 #define OP_AggStep 147 12676 #define OP_AggFinal 148 12677 #define OP_Expire 149 12678 #define OP_TableLock 150 12679 #define OP_VBegin 151 12680 #define OP_VCreate 152 12681 #define OP_VDestroy 153 12682 #define OP_VOpen 154 12683 #define OP_VColumn 155 12684 #define OP_VRename 156 12685 #define OP_Pagecount 157 12686 #define OP_MaxPgcnt 158 12687 #define OP_CursorHint 159 12688 #define OP_Noop 160 12689 #define OP_Explain 161 12695 #define OPFLG_JUMP 0x01 12696 #define OPFLG_IN1 0x02 12697 #define OPFLG_IN2 0x04 12698 #define OPFLG_IN3 0x08 12699 #define OPFLG_OUT2 0x10 12700 #define OPFLG_OUT3 0x20 12701 #define OPFLG_INITIALIZER {\ 12702 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01,\ 12703 0x00, 0x10, 0x00, 0x01, 0x00, 0x01, 0x01, 0x01,\ 12704 0x03, 0x03, 0x01, 0x12, 0x01, 0x03, 0x03, 0x09,\ 12705 0x09, 0x09, 0x09, 0x26, 0x26, 0x09, 0x09, 0x09,\ 12706 0x09, 0x09, 0x03, 0x03, 0x0b, 0x0b, 0x0b, 0x0b,\ 12707 0x0b, 0x0b, 0x01, 0x26, 0x26, 0x26, 0x26, 0x26,\ 12708 0x26, 0x26, 0x26, 0x26, 0x26, 0x01, 0x12, 0x01,\ 12709 0x01, 0x01, 0x01, 0x01, 0x01, 0x23, 0x0b, 0x01,\ 12710 0x01, 0x03, 0x03, 0x03, 0x01, 0x01, 0x01, 0x02,\ 12711 0x02, 0x08, 0x00, 0x10, 0x10, 0x10, 0x10, 0x00,\ 12712 0x10, 0x10, 0x00, 0x00, 0x10, 0x10, 0x00, 0x00,\ 12713 0x00, 0x00, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00,\ 12714 0x00, 0x10, 0x00, 0x10, 0x10, 0x00, 0x00, 0x00,\ 12715 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\ 12716 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\ 12717 0x00, 0x00, 0x10, 0x00, 0x04, 0x04, 0x00, 0x00,\ 12718 0x10, 0x10, 0x00, 0x00, 0x10, 0x10, 0x10, 0x00,\ 12719 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x10, 0x00,\ 12720 0x04, 0x1a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\ 12721 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x00,\ 12730 #define SQLITE_MX_JUMP_OPCODE 70 12739 SQLITE_PRIVATE Vdbe *sqlite3VdbeCreate(Parse*);
12740 SQLITE_PRIVATE
int sqlite3VdbeAddOp0(Vdbe*,
int);
12741 SQLITE_PRIVATE
int sqlite3VdbeAddOp1(Vdbe*,
int,
int);
12742 SQLITE_PRIVATE
int sqlite3VdbeAddOp2(Vdbe*,
int,
int,
int);
12743 SQLITE_PRIVATE
int sqlite3VdbeGoto(Vdbe*,
int);
12744 SQLITE_PRIVATE
int sqlite3VdbeLoadString(Vdbe*,
int,
const char*);
12745 SQLITE_PRIVATE
void sqlite3VdbeMultiLoad(Vdbe*,
int,
const char*,...);
12746 SQLITE_PRIVATE
int sqlite3VdbeAddOp3(Vdbe*,
int,
int,
int,
int);
12747 SQLITE_PRIVATE
int sqlite3VdbeAddOp4(Vdbe*,
int,
int,
int,
int,
const char *zP4,
int);
12748 SQLITE_PRIVATE
int sqlite3VdbeAddOp4Dup8(Vdbe*,
int,
int,
int,
int,
const u8*,
int);
12749 SQLITE_PRIVATE
int sqlite3VdbeAddOp4Int(Vdbe*,
int,
int,
int,
int,
int);
12750 SQLITE_PRIVATE
void sqlite3VdbeEndCoroutine(Vdbe*,
int);
12751 #if defined(SQLITE_DEBUG) && !defined(SQLITE_TEST_REALLOC_STRESS) 12752 SQLITE_PRIVATE
void sqlite3VdbeVerifyNoMallocRequired(Vdbe *p,
int N);
12754 # define sqlite3VdbeVerifyNoMallocRequired(A,B) 12756 SQLITE_PRIVATE VdbeOp *sqlite3VdbeAddOpList(Vdbe*,
int nOp, VdbeOpList
const *aOp,
int iLineno);
12757 SQLITE_PRIVATE
void sqlite3VdbeAddParseSchemaOp(Vdbe*,
int,
char*);
12758 SQLITE_PRIVATE
void sqlite3VdbeChangeOpcode(Vdbe*, u32 addr, u8);
12759 SQLITE_PRIVATE
void sqlite3VdbeChangeP1(Vdbe*, u32 addr,
int P1);
12760 SQLITE_PRIVATE
void sqlite3VdbeChangeP2(Vdbe*, u32 addr,
int P2);
12761 SQLITE_PRIVATE
void sqlite3VdbeChangeP3(Vdbe*, u32 addr,
int P3);
12762 SQLITE_PRIVATE
void sqlite3VdbeChangeP5(Vdbe*, u8 P5);
12763 SQLITE_PRIVATE
void sqlite3VdbeJumpHere(Vdbe*,
int addr);
12764 SQLITE_PRIVATE
int sqlite3VdbeChangeToNoop(Vdbe*,
int addr);
12765 SQLITE_PRIVATE
int sqlite3VdbeDeletePriorOpcode(Vdbe*, u8 op);
12766 SQLITE_PRIVATE
void sqlite3VdbeChangeP4(Vdbe*,
int addr,
const char *zP4,
int N);
12767 SQLITE_PRIVATE
void sqlite3VdbeSetP4KeyInfo(Parse*, Index*);
12768 SQLITE_PRIVATE
void sqlite3VdbeUsesBtree(Vdbe*,
int);
12769 SQLITE_PRIVATE VdbeOp *sqlite3VdbeGetOp(Vdbe*,
int);
12770 SQLITE_PRIVATE
int sqlite3VdbeMakeLabel(Vdbe*);
12771 SQLITE_PRIVATE
void sqlite3VdbeRunOnlyOnce(Vdbe*);
12772 SQLITE_PRIVATE
void sqlite3VdbeReusable(Vdbe*);
12773 SQLITE_PRIVATE
void sqlite3VdbeDelete(Vdbe*);
12774 SQLITE_PRIVATE
void sqlite3VdbeClearObject(
sqlite3*,Vdbe*);
12775 SQLITE_PRIVATE
void sqlite3VdbeMakeReady(Vdbe*,Parse*);
12776 SQLITE_PRIVATE
int sqlite3VdbeFinalize(Vdbe*);
12777 SQLITE_PRIVATE
void sqlite3VdbeResolveLabel(Vdbe*,
int);
12778 SQLITE_PRIVATE
int sqlite3VdbeCurrentAddr(Vdbe*);
12779 #ifdef SQLITE_DEBUG 12780 SQLITE_PRIVATE
int sqlite3VdbeAssertMayAbort(Vdbe *,
int);
12782 SQLITE_PRIVATE
void sqlite3VdbeResetStepResult(Vdbe*);
12783 SQLITE_PRIVATE
void sqlite3VdbeRewind(Vdbe*);
12784 SQLITE_PRIVATE
int sqlite3VdbeReset(Vdbe*);
12785 SQLITE_PRIVATE
void sqlite3VdbeSetNumCols(Vdbe*,
int);
12786 SQLITE_PRIVATE
int sqlite3VdbeSetColName(Vdbe*,
int,
int,
const char *,
void(*)(
void*));
12787 SQLITE_PRIVATE
void sqlite3VdbeCountChanges(Vdbe*);
12788 SQLITE_PRIVATE
sqlite3 *sqlite3VdbeDb(Vdbe*);
12789 SQLITE_PRIVATE
void sqlite3VdbeSetSql(Vdbe*,
const char *z,
int n,
int);
12790 SQLITE_PRIVATE
void sqlite3VdbeSwap(Vdbe*,Vdbe*);
12791 SQLITE_PRIVATE VdbeOp *sqlite3VdbeTakeOpArray(Vdbe*,
int*,
int*);
12792 SQLITE_PRIVATE
sqlite3_value *sqlite3VdbeGetBoundValue(Vdbe*,
int, u8);
12793 SQLITE_PRIVATE
void sqlite3VdbeSetVarmask(Vdbe*,
int);
12794 #ifndef SQLITE_OMIT_TRACE 12795 SQLITE_PRIVATE
char *sqlite3VdbeExpandSql(Vdbe*,
const char*);
12797 SQLITE_PRIVATE
int sqlite3MemCompare(
const Mem*,
const Mem*,
const CollSeq*);
12799 SQLITE_PRIVATE
void sqlite3VdbeRecordUnpack(KeyInfo*,
int,
const void*,UnpackedRecord*);
12800 SQLITE_PRIVATE
int sqlite3VdbeRecordCompare(
int,
const void*,UnpackedRecord*);
12801 SQLITE_PRIVATE
int sqlite3VdbeRecordCompareWithSkip(
int,
const void *, UnpackedRecord *,
int);
12802 SQLITE_PRIVATE UnpackedRecord *sqlite3VdbeAllocUnpackedRecord(KeyInfo *,
char *,
int,
char **);
12804 typedef int (*RecordCompare)(int,
const void*,UnpackedRecord*);
12805 SQLITE_PRIVATE RecordCompare sqlite3VdbeFindCompare(UnpackedRecord*);
12807 #ifndef SQLITE_OMIT_TRIGGER 12808 SQLITE_PRIVATE
void sqlite3VdbeLinkSubProgram(Vdbe *, SubProgram *);
12818 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS 12819 SQLITE_PRIVATE
void sqlite3VdbeComment(Vdbe*,
const char*, ...);
12820 # define VdbeComment(X) sqlite3VdbeComment X 12821 SQLITE_PRIVATE
void sqlite3VdbeNoopComment(Vdbe*,
const char*, ...);
12822 # define VdbeNoopComment(X) sqlite3VdbeNoopComment X 12823 # ifdef SQLITE_ENABLE_MODULE_COMMENTS 12824 # define VdbeModuleComment(X) sqlite3VdbeNoopComment X 12826 # define VdbeModuleComment(X) 12829 # define VdbeComment(X) 12830 # define VdbeNoopComment(X) 12831 # define VdbeModuleComment(X) 12856 #ifdef SQLITE_VDBE_COVERAGE 12857 SQLITE_PRIVATE
void sqlite3VdbeSetLineNumber(Vdbe*,
int);
12858 # define VdbeCoverage(v) sqlite3VdbeSetLineNumber(v,__LINE__) 12859 # define VdbeCoverageIf(v,x) if(x)sqlite3VdbeSetLineNumber(v,__LINE__) 12860 # define VdbeCoverageAlwaysTaken(v) sqlite3VdbeSetLineNumber(v,2); 12861 # define VdbeCoverageNeverTaken(v) sqlite3VdbeSetLineNumber(v,1); 12862 # define VDBE_OFFSET_LINENO(x) (__LINE__+x) 12864 # define VdbeCoverage(v) 12865 # define VdbeCoverageIf(v,x) 12866 # define VdbeCoverageAlwaysTaken(v) 12867 # define VdbeCoverageNeverTaken(v) 12868 # define VDBE_OFFSET_LINENO(x) 0 12871 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS 12872 SQLITE_PRIVATE
void sqlite3VdbeScanStatus(Vdbe*,
int,
int,
int, LogEst,
const char*);
12874 # define sqlite3VdbeScanStatus(a,b,c,d,e) 12899 #ifndef SQLITE_PAGER_H 12900 #define SQLITE_PAGER_H 12907 #ifndef SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT 12908 #define SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT -1 12920 typedef struct Pager Pager;
12925 typedef struct PgHdr DbPage;
12935 #define PAGER_MJ_PGNO(x) ((Pgno)((PENDING_BYTE/((x)->pageSize))+1)) 12942 #define PAGER_OMIT_JOURNAL 0x0001 12943 #define PAGER_MEMORY 0x0002 12948 #define PAGER_LOCKINGMODE_QUERY -1 12949 #define PAGER_LOCKINGMODE_NORMAL 0 12950 #define PAGER_LOCKINGMODE_EXCLUSIVE 1 12959 #define PAGER_JOURNALMODE_QUERY (-1) 12960 #define PAGER_JOURNALMODE_DELETE 0 12961 #define PAGER_JOURNALMODE_PERSIST 1 12962 #define PAGER_JOURNALMODE_OFF 2 12963 #define PAGER_JOURNALMODE_TRUNCATE 3 12964 #define PAGER_JOURNALMODE_MEMORY 4 12965 #define PAGER_JOURNALMODE_WAL 5 12970 #define PAGER_GET_NOCONTENT 0x01 12971 #define PAGER_GET_READONLY 0x02 12981 #define PAGER_SYNCHRONOUS_OFF 0x01 12982 #define PAGER_SYNCHRONOUS_NORMAL 0x02 12983 #define PAGER_SYNCHRONOUS_FULL 0x03 12984 #define PAGER_SYNCHRONOUS_EXTRA 0x04 12985 #define PAGER_SYNCHRONOUS_MASK 0x07 12986 #define PAGER_FULLFSYNC 0x08 12987 #define PAGER_CKPT_FULLFSYNC 0x10 12988 #define PAGER_CACHESPILL 0x20 12989 #define PAGER_FLAGS_MASK 0x38 12998 SQLITE_PRIVATE
int sqlite3PagerOpen(
13007 SQLITE_PRIVATE
int sqlite3PagerClose(Pager *pPager);
13008 SQLITE_PRIVATE
int sqlite3PagerReadFileheader(Pager*,
int,
unsigned char*);
13011 SQLITE_PRIVATE
void sqlite3PagerSetBusyhandler(Pager*,
int(*)(
void *),
void *);
13012 SQLITE_PRIVATE
int sqlite3PagerSetPagesize(Pager*, u32*,
int);
13013 #ifdef SQLITE_HAS_CODEC 13014 SQLITE_PRIVATE
void sqlite3PagerAlignReserve(Pager*,Pager*);
13016 SQLITE_PRIVATE
int sqlite3PagerMaxPageCount(Pager*,
int);
13017 SQLITE_PRIVATE
void sqlite3PagerSetCachesize(Pager*,
int);
13018 SQLITE_PRIVATE
int sqlite3PagerSetSpillsize(Pager*,
int);
13019 SQLITE_PRIVATE
void sqlite3PagerSetMmapLimit(Pager *, sqlite3_int64);
13020 SQLITE_PRIVATE
void sqlite3PagerShrink(Pager*);
13021 SQLITE_PRIVATE
void sqlite3PagerSetFlags(Pager*,
unsigned);
13022 SQLITE_PRIVATE
int sqlite3PagerLockingMode(Pager *,
int);
13023 SQLITE_PRIVATE
int sqlite3PagerSetJournalMode(Pager *,
int);
13024 SQLITE_PRIVATE
int sqlite3PagerGetJournalMode(Pager*);
13025 SQLITE_PRIVATE
int sqlite3PagerOkToChangeJournalMode(Pager*);
13026 SQLITE_PRIVATE i64 sqlite3PagerJournalSizeLimit(Pager *, i64);
13028 SQLITE_PRIVATE
int sqlite3PagerFlush(Pager*);
13031 SQLITE_PRIVATE
int sqlite3PagerGet(Pager *pPager, Pgno pgno, DbPage **ppPage,
int clrFlag);
13032 SQLITE_PRIVATE DbPage *sqlite3PagerLookup(Pager *pPager, Pgno pgno);
13033 SQLITE_PRIVATE
void sqlite3PagerRef(DbPage*);
13034 SQLITE_PRIVATE
void sqlite3PagerUnref(DbPage*);
13035 SQLITE_PRIVATE
void sqlite3PagerUnrefNotNull(DbPage*);
13038 SQLITE_PRIVATE
int sqlite3PagerWrite(DbPage*);
13039 SQLITE_PRIVATE
void sqlite3PagerDontWrite(DbPage*);
13040 SQLITE_PRIVATE
int sqlite3PagerMovepage(Pager*,DbPage*,Pgno,
int);
13041 SQLITE_PRIVATE
int sqlite3PagerPageRefcount(DbPage*);
13042 SQLITE_PRIVATE
void *sqlite3PagerGetData(DbPage *);
13043 SQLITE_PRIVATE
void *sqlite3PagerGetExtra(DbPage *);
13046 SQLITE_PRIVATE
void sqlite3PagerPagecount(Pager*,
int*);
13047 SQLITE_PRIVATE
int sqlite3PagerBegin(Pager*,
int exFlag,
int);
13048 SQLITE_PRIVATE
int sqlite3PagerCommitPhaseOne(Pager*,
const char *zMaster,
int);
13049 SQLITE_PRIVATE
int sqlite3PagerExclusiveLock(Pager*);
13050 SQLITE_PRIVATE
int sqlite3PagerSync(Pager *pPager,
const char *zMaster);
13051 SQLITE_PRIVATE
int sqlite3PagerCommitPhaseTwo(Pager*);
13052 SQLITE_PRIVATE
int sqlite3PagerRollback(Pager*);
13053 SQLITE_PRIVATE
int sqlite3PagerOpenSavepoint(Pager *pPager,
int n);
13054 SQLITE_PRIVATE
int sqlite3PagerSavepoint(Pager *pPager,
int op,
int iSavepoint);
13055 SQLITE_PRIVATE
int sqlite3PagerSharedLock(Pager *pPager);
13057 #ifndef SQLITE_OMIT_WAL 13058 SQLITE_PRIVATE
int sqlite3PagerCheckpoint(Pager *pPager,
int,
int*,
int*);
13059 SQLITE_PRIVATE
int sqlite3PagerWalSupported(Pager *pPager);
13060 SQLITE_PRIVATE
int sqlite3PagerWalCallback(Pager *pPager);
13061 SQLITE_PRIVATE
int sqlite3PagerOpenWal(Pager *pPager,
int *pisOpen);
13062 SQLITE_PRIVATE
int sqlite3PagerCloseWal(Pager *pPager);
13063 # ifdef SQLITE_ENABLE_SNAPSHOT 13064 SQLITE_PRIVATE
int sqlite3PagerSnapshotGet(Pager *pPager, sqlite3_snapshot **ppSnapshot);
13065 SQLITE_PRIVATE
int sqlite3PagerSnapshotOpen(Pager *pPager, sqlite3_snapshot *pSnapshot);
13069 #ifdef SQLITE_ENABLE_ZIPVFS 13070 SQLITE_PRIVATE
int sqlite3PagerWalFramesize(Pager *pPager);
13074 SQLITE_PRIVATE u8 sqlite3PagerIsreadonly(Pager*);
13075 SQLITE_PRIVATE u32 sqlite3PagerDataVersion(Pager*);
13076 #ifdef SQLITE_DEBUG 13077 SQLITE_PRIVATE
int sqlite3PagerRefcount(Pager*);
13079 SQLITE_PRIVATE
int sqlite3PagerMemUsed(Pager*);
13080 SQLITE_PRIVATE
const char *sqlite3PagerFilename(Pager*,
int);
13081 SQLITE_PRIVATE
sqlite3_vfs *sqlite3PagerVfs(Pager*);
13082 SQLITE_PRIVATE
sqlite3_file *sqlite3PagerFile(Pager*);
13083 SQLITE_PRIVATE
sqlite3_file *sqlite3PagerJrnlFile(Pager*);
13084 SQLITE_PRIVATE
const char *sqlite3PagerJournalname(Pager*);
13085 SQLITE_PRIVATE
void *sqlite3PagerTempSpace(Pager*);
13086 SQLITE_PRIVATE
int sqlite3PagerIsMemdb(Pager*);
13087 SQLITE_PRIVATE
void sqlite3PagerCacheStat(Pager *,
int,
int,
int *);
13088 SQLITE_PRIVATE
void sqlite3PagerClearCache(Pager*);
13092 SQLITE_PRIVATE
void sqlite3PagerTruncateImage(Pager*,Pgno);
13094 SQLITE_PRIVATE
void sqlite3PagerRekey(DbPage*, Pgno, u16);
13096 #if defined(SQLITE_HAS_CODEC) && !defined(SQLITE_OMIT_WAL) 13097 SQLITE_PRIVATE
void *sqlite3PagerCodec(DbPage *);
13101 #if !defined(NDEBUG) || defined(SQLITE_TEST) 13102 SQLITE_PRIVATE Pgno sqlite3PagerPagenumber(DbPage*);
13103 SQLITE_PRIVATE
int sqlite3PagerIswriteable(DbPage*);
13106 SQLITE_PRIVATE
int *sqlite3PagerStats(Pager*);
13107 SQLITE_PRIVATE
void sqlite3PagerRefdump(Pager*);
13108 void disable_simulated_io_errors(
void);
13109 void enable_simulated_io_errors(
void);
13111 # define disable_simulated_io_errors() 13112 # define enable_simulated_io_errors() 13138 typedef struct PgHdr PgHdr;
13139 typedef struct PCache PCache;
13152 #ifdef SQLITE_CHECK_PAGES 13169 #define PGHDR_CLEAN 0x001 13170 #define PGHDR_DIRTY 0x002 13171 #define PGHDR_WRITEABLE 0x004 13172 #define PGHDR_NEED_SYNC 0x008 13174 #define PGHDR_DONT_WRITE 0x010 13175 #define PGHDR_MMAP 0x020 13177 #define PGHDR_WAL_APPEND 0x040 13180 SQLITE_PRIVATE
int sqlite3PcacheInitialize(
void);
13181 SQLITE_PRIVATE
void sqlite3PcacheShutdown(
void);
13186 SQLITE_PRIVATE
void sqlite3PCacheBufferSetup(
void *,
int sz,
int n);
13192 SQLITE_PRIVATE
int sqlite3PcacheOpen(
13196 int (*xStress)(
void*, PgHdr*),
13202 SQLITE_PRIVATE
int sqlite3PcacheSetPageSize(PCache *,
int);
13207 SQLITE_PRIVATE
int sqlite3PcacheSize(
void);
13214 SQLITE_PRIVATE PgHdr *sqlite3PcacheFetchFinish(PCache*, Pgno,
sqlite3_pcache_page *pPage);
13215 SQLITE_PRIVATE
void sqlite3PcacheRelease(PgHdr*);
13217 SQLITE_PRIVATE
void sqlite3PcacheDrop(PgHdr*);
13218 SQLITE_PRIVATE
void sqlite3PcacheMakeDirty(PgHdr*);
13219 SQLITE_PRIVATE
void sqlite3PcacheMakeClean(PgHdr*);
13220 SQLITE_PRIVATE
void sqlite3PcacheCleanAll(PCache*);
13221 SQLITE_PRIVATE
void sqlite3PcacheClearWritable(PCache*);
13224 SQLITE_PRIVATE
void sqlite3PcacheMove(PgHdr*, Pgno);
13227 SQLITE_PRIVATE
void sqlite3PcacheTruncate(PCache*, Pgno x);
13230 SQLITE_PRIVATE PgHdr *sqlite3PcacheDirtyList(PCache*);
13233 SQLITE_PRIVATE
void sqlite3PcacheClose(PCache*);
13236 SQLITE_PRIVATE
void sqlite3PcacheClearSyncFlags(PCache *);
13239 SQLITE_PRIVATE
void sqlite3PcacheClear(PCache*);
13242 SQLITE_PRIVATE
int sqlite3PcacheRefCount(PCache*);
13245 SQLITE_PRIVATE
void sqlite3PcacheRef(PgHdr*);
13247 SQLITE_PRIVATE
int sqlite3PcachePageRefcount(PgHdr*);
13250 SQLITE_PRIVATE
int sqlite3PcachePagecount(PCache*);
13252 #if defined(SQLITE_CHECK_PAGES) || defined(SQLITE_DEBUG) 13257 SQLITE_PRIVATE
void sqlite3PcacheIterateDirty(PCache *pCache,
void (*xIter)(PgHdr *));
13260 #if defined(SQLITE_DEBUG) 13262 SQLITE_PRIVATE
int sqlite3PcachePageSanity(PgHdr*);
13271 SQLITE_PRIVATE
void sqlite3PcacheSetCachesize(PCache *,
int);
13273 SQLITE_PRIVATE
int sqlite3PcacheGetCachesize(PCache *);
13281 SQLITE_PRIVATE
int sqlite3PcacheSetSpillsize(PCache *,
int);
13284 SQLITE_PRIVATE
void sqlite3PcacheShrink(PCache*);
13286 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT 13288 SQLITE_PRIVATE
int sqlite3PcacheReleaseMemory(
int);
13292 SQLITE_PRIVATE
void sqlite3PcacheStats(
int*,
int*,
int*,
int*);
13295 SQLITE_PRIVATE
void sqlite3PCacheSetDefault(
void);
13298 SQLITE_PRIVATE
int sqlite3HeaderSizePcache(
void);
13299 SQLITE_PRIVATE
int sqlite3HeaderSizePcache1(
void);
13302 SQLITE_PRIVATE
int sqlite3PCachePercentDirty(PCache*);
13329 #ifndef _SQLITE_OS_H_ 13330 #define _SQLITE_OS_H_ 13353 #ifndef SQLITE_OS_SETUP_H 13354 #define SQLITE_OS_SETUP_H 13364 #if defined(SQLITE_OS_OTHER) 13365 # if SQLITE_OS_OTHER==1 13366 # undef SQLITE_OS_UNIX 13367 # define SQLITE_OS_UNIX 0 13368 # undef SQLITE_OS_WIN 13369 # define SQLITE_OS_WIN 0 13371 # undef SQLITE_OS_OTHER 13374 #if !defined(SQLITE_OS_UNIX) && !defined(SQLITE_OS_OTHER) 13375 # define SQLITE_OS_OTHER 0 13376 # ifndef SQLITE_OS_WIN 13377 # if defined(_WIN32) || defined(WIN32) || defined(__CYGWIN__) || \ 13378 defined(__MINGW32__) || defined(__BORLANDC__) 13379 # define SQLITE_OS_WIN 1 13380 # define SQLITE_OS_UNIX 0 13382 # define SQLITE_OS_WIN 0 13383 # define SQLITE_OS_UNIX 1 13386 # define SQLITE_OS_UNIX 0 13389 # ifndef SQLITE_OS_WIN 13390 # define SQLITE_OS_WIN 0 13402 #ifndef SET_FULLSYNC 13403 # define SET_FULLSYNC(x,y) 13409 #ifndef SQLITE_DEFAULT_SECTOR_SIZE 13410 # define SQLITE_DEFAULT_SECTOR_SIZE 4096 13434 #ifndef SQLITE_TEMP_FILE_PREFIX 13435 # define SQLITE_TEMP_FILE_PREFIX "etilqs_" 13456 #define SHARED_LOCK 1 13457 #define RESERVED_LOCK 2 13458 #define PENDING_LOCK 3 13459 #define EXCLUSIVE_LOCK 4 13516 #ifdef SQLITE_OMIT_WSD 13517 # define PENDING_BYTE (0x40000000) 13519 # define PENDING_BYTE sqlite3PendingByte 13521 #define RESERVED_BYTE (PENDING_BYTE+1) 13522 #define SHARED_FIRST (PENDING_BYTE+2) 13523 #define SHARED_SIZE 510 13528 SQLITE_PRIVATE
int sqlite3OsInit(
void);
13534 SQLITE_PRIVATE
int sqlite3OsRead(
sqlite3_file*,
void*,
int amt, i64 offset);
13535 SQLITE_PRIVATE
int sqlite3OsWrite(
sqlite3_file*,
const void*,
int amt, i64 offset);
13536 SQLITE_PRIVATE
int sqlite3OsTruncate(
sqlite3_file*, i64 size);
13538 SQLITE_PRIVATE
int sqlite3OsFileSize(
sqlite3_file*, i64 *pSize);
13540 SQLITE_PRIVATE
int sqlite3OsUnlock(
sqlite3_file*,
int);
13541 SQLITE_PRIVATE
int sqlite3OsCheckReservedLock(
sqlite3_file *
id,
int *pResOut);
13542 SQLITE_PRIVATE
int sqlite3OsFileControl(
sqlite3_file*,
int,
void*);
13543 SQLITE_PRIVATE
void sqlite3OsFileControlHint(
sqlite3_file*,
int,
void*);
13544 #define SQLITE_FCNTL_DB_UNCHANGED 0xca093fa0 13545 SQLITE_PRIVATE
int sqlite3OsSectorSize(
sqlite3_file *
id);
13546 SQLITE_PRIVATE
int sqlite3OsDeviceCharacteristics(
sqlite3_file *
id);
13547 SQLITE_PRIVATE
int sqlite3OsShmMap(
sqlite3_file *,
int,
int,
int,
void volatile **);
13548 SQLITE_PRIVATE
int sqlite3OsShmLock(
sqlite3_file *
id,
int,
int,
int);
13549 SQLITE_PRIVATE
void sqlite3OsShmBarrier(
sqlite3_file *
id);
13550 SQLITE_PRIVATE
int sqlite3OsShmUnmap(
sqlite3_file *
id,
int);
13551 SQLITE_PRIVATE
int sqlite3OsFetch(
sqlite3_file *
id, i64,
int,
void **);
13552 SQLITE_PRIVATE
int sqlite3OsUnfetch(
sqlite3_file *, i64,
void *);
13559 SQLITE_PRIVATE
int sqlite3OsDelete(
sqlite3_vfs *,
const char *,
int);
13560 SQLITE_PRIVATE
int sqlite3OsAccess(
sqlite3_vfs *,
const char *,
int,
int *pResOut);
13561 SQLITE_PRIVATE
int sqlite3OsFullPathname(
sqlite3_vfs *,
const char *,
int,
char *);
13562 #ifndef SQLITE_OMIT_LOAD_EXTENSION 13563 SQLITE_PRIVATE
void *sqlite3OsDlOpen(
sqlite3_vfs *,
const char *);
13564 SQLITE_PRIVATE
void sqlite3OsDlError(
sqlite3_vfs *,
int,
char *);
13565 SQLITE_PRIVATE void (*sqlite3OsDlSym(
sqlite3_vfs *,
void *,
const char *))(void);
13566 SQLITE_PRIVATE
void sqlite3OsDlClose(
sqlite3_vfs *,
void *);
13568 SQLITE_PRIVATE
int sqlite3OsRandomness(
sqlite3_vfs *,
int,
char *);
13569 SQLITE_PRIVATE
int sqlite3OsSleep(
sqlite3_vfs *,
int);
13570 SQLITE_PRIVATE
int sqlite3OsGetLastError(
sqlite3_vfs*);
13571 SQLITE_PRIVATE
int sqlite3OsCurrentTimeInt64(
sqlite3_vfs *, sqlite3_int64*);
13578 SQLITE_PRIVATE
void sqlite3OsCloseFree(
sqlite3_file *);
13625 #if !SQLITE_THREADSAFE 13626 # define SQLITE_MUTEX_OMIT 13628 #if SQLITE_THREADSAFE && !defined(SQLITE_MUTEX_NOOP) 13629 # if SQLITE_OS_UNIX 13630 # define SQLITE_MUTEX_PTHREADS 13631 # elif SQLITE_OS_WIN 13632 # define SQLITE_MUTEX_W32 13634 # define SQLITE_MUTEX_NOOP 13638 #ifdef SQLITE_MUTEX_OMIT 13642 #define sqlite3_mutex_alloc(X) ((sqlite3_mutex*)8) 13643 #define sqlite3_mutex_free(X) 13644 #define sqlite3_mutex_enter(X) 13645 #define sqlite3_mutex_try(X) SQLITE_OK 13646 #define sqlite3_mutex_leave(X) 13647 #define sqlite3_mutex_held(X) ((void)(X),1) 13648 #define sqlite3_mutex_notheld(X) ((void)(X),1) 13649 #define sqlite3MutexAlloc(X) ((sqlite3_mutex*)8) 13650 #define sqlite3MutexInit() SQLITE_OK 13651 #define sqlite3MutexEnd() 13652 #define MUTEX_LOGIC(X) 13654 #define MUTEX_LOGIC(X) X 13663 #ifdef SQLITE_EXTRA_DURABLE 13664 # warning Use SQLITE_DEFAULT_SYNCHRONOUS=3 instead of SQLITE_EXTRA_DURABLE 13665 # define SQLITE_DEFAULT_SYNCHRONOUS 3 13684 #ifndef SQLITE_DEFAULT_SYNCHRONOUS 13685 # define SQLITE_DEFAULT_SYNCHRONOUS (PAGER_SYNCHRONOUS_FULL-1) 13687 #ifndef SQLITE_DEFAULT_WAL_SYNCHRONOUS 13688 # define SQLITE_DEFAULT_WAL_SYNCHRONOUS SQLITE_DEFAULT_SYNCHRONOUS 13741 #define DbHasProperty(D,I,P) (((D)->aDb[I].pSchema->schemaFlags&(P))==(P)) 13742 #define DbHasAnyProperty(D,I,P) (((D)->aDb[I].pSchema->schemaFlags&(P))!=0) 13743 #define DbSetProperty(D,I,P) (D)->aDb[I].pSchema->schemaFlags|=(P) 13744 #define DbClearProperty(D,I,P) (D)->aDb[I].pSchema->schemaFlags&=~(P) 13756 #define DB_SchemaLoaded 0x0001 13757 #define DB_UnresetViews 0x0002 13758 #define DB_Empty 0x0004 13764 #define SQLITE_N_LIMIT (SQLITE_LIMIT_WORKER_THREADS+1) 13793 LookasideSlot *pFree;
13797 struct LookasideSlot {
13798 LookasideSlot *pNext;
13808 #define SQLITE_FUNC_HASH_SZ 23 13809 struct FuncDefHash {
13810 FuncDef *a[SQLITE_FUNC_HASH_SZ];
13813 #ifdef SQLITE_USER_AUTHENTICATION 13818 typedef struct sqlite3_userauth sqlite3_userauth;
13819 struct sqlite3_userauth {
13827 #define UAUTH_Unknown 0 13828 #define UAUTH_Fail 1 13829 #define UAUTH_User 2 13830 #define UAUTH_Admin 3 13833 SQLITE_PRIVATE
int sqlite3UserAuthTable(
const char*);
13834 SQLITE_PRIVATE
int sqlite3UserAuthCheckLogin(
sqlite3*,
const char*,u8*);
13835 SQLITE_PRIVATE
void sqlite3UserAuthInit(
sqlite3*);
13843 #ifdef SQLITE_USER_AUTHENTICATION 13844 typedef int (*sqlite3_xauth)(
void*,int,
const char*,
const char*,
const char*,
13845 const char*,
const char*);
13847 typedef int (*sqlite3_xauth)(
void*,int,
const char*,
const char*,
const char*,
13851 #ifndef SQLITE_OMIT_DEPRECATED 13855 #define SQLITE_TRACE_LEGACY 0x80 13857 #define SQLITE_TRACE_LEGACY 0 13866 struct Vdbe *pVdbe;
13867 CollSeq *pDfltColl;
13874 unsigned int openFlags;
13885 signed char nextAutovac;
13888 u8 isTransactionSavepoint;
13894 int aLimit[SQLITE_N_LIMIT];
13895 int nMaxSorterMmap;
13910 int (*xTrace)(u32,
void*,
void*,
void*);
13912 void (*xProfile)(
void*,
const char*,u64);
13915 int (*xCommitCallback)(
void*);
13916 void *pRollbackArg;
13917 void (*xRollbackCallback)(
void*);
13919 void (*xUpdateCallback)(
void*,int,
const char*,
const char*,sqlite_int64);
13920 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK 13921 void *pPreUpdateArg;
13922 void (*xPreUpdateCallback)(
13923 void*,
sqlite3*,int,
char const*,
char const*,sqlite3_int64,sqlite3_int64
13925 PreUpdate *pPreUpdate;
13927 #ifndef SQLITE_OMIT_WAL 13928 int (*xWalCallback)(
void *, sqlite3 *,
const char *, int);
13931 void(*xCollNeeded)(
void*,sqlite3*,
int eTextRep,
const char*);
13932 void(*xCollNeeded16)(
void*,sqlite3*,
int eTextRep,
const void*);
13933 void *pCollNeededArg;
13936 volatile int isInterrupted;
13939 Lookaside lookaside;
13940 #ifndef SQLITE_OMIT_AUTHORIZATION 13941 sqlite3_xauth xAuth;
13944 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK 13945 int (*xProgress)(
void *);
13946 void *pProgressArg;
13947 unsigned nProgressOps;
13949 #ifndef SQLITE_OMIT_VIRTUALTABLE 13954 VTable *pDisconnect;
13958 BusyHandler busyHandler;
13960 Savepoint *pSavepoint;
13965 i64 nDeferredImmCons;
13967 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY 13978 sqlite3 *pBlockingConnection;
13979 sqlite3 *pUnlockConnection;
13981 void (*xUnlockNotify)(
void **, int);
13982 sqlite3 *pNextBlocked;
13984 #ifdef SQLITE_USER_AUTHENTICATION 13985 sqlite3_userauth auth;
13992 #define SCHEMA_ENC(db) ((db)->aDb[0].pSchema->enc) 13993 #define ENC(db) ((db)->enc) 14003 #define SQLITE_VdbeTrace 0x00000001 14004 #define SQLITE_InternChanges 0x00000002 14005 #define SQLITE_FullColNames 0x00000004 14006 #define SQLITE_FullFSync 0x00000008 14007 #define SQLITE_CkptFullFSync 0x00000010 14008 #define SQLITE_CacheSpill 0x00000020 14009 #define SQLITE_ShortColNames 0x00000040 14010 #define SQLITE_CountRows 0x00000080 14013 #define SQLITE_NullCallback 0x00000100 14015 #define SQLITE_SqlTrace 0x00000200 14016 #define SQLITE_VdbeListing 0x00000400 14017 #define SQLITE_WriteSchema 0x00000800 14018 #define SQLITE_VdbeAddopTrace 0x00001000 14019 #define SQLITE_IgnoreChecks 0x00002000 14020 #define SQLITE_ReadUncommitted 0x0004000 14021 #define SQLITE_LegacyFileFmt 0x00008000 14022 #define SQLITE_RecoveryMode 0x00010000 14023 #define SQLITE_ReverseOrder 0x00020000 14024 #define SQLITE_RecTriggers 0x00040000 14025 #define SQLITE_ForeignKeys 0x00080000 14026 #define SQLITE_AutoIndex 0x00100000 14027 #define SQLITE_PreferBuiltin 0x00200000 14028 #define SQLITE_LoadExtension 0x00400000 14029 #define SQLITE_LoadExtFunc 0x00800000 14030 #define SQLITE_EnableTrigger 0x01000000 14031 #define SQLITE_DeferFKs 0x02000000 14032 #define SQLITE_QueryOnly 0x04000000 14033 #define SQLITE_VdbeEQP 0x08000000 14034 #define SQLITE_Vacuum 0x10000000 14035 #define SQLITE_CellSizeCk 0x20000000 14036 #define SQLITE_Fts3Tokenizer 0x40000000 14044 #define SQLITE_QueryFlattener 0x0001 14045 #define SQLITE_ColumnCache 0x0002 14046 #define SQLITE_GroupByOrder 0x0004 14047 #define SQLITE_FactorOutConst 0x0008 14049 #define SQLITE_DistinctOpt 0x0020 14050 #define SQLITE_CoverIdxScan 0x0040 14051 #define SQLITE_OrderByIdxJoin 0x0080 14052 #define SQLITE_SubqCoroutine 0x0100 14053 #define SQLITE_Transitive 0x0200 14054 #define SQLITE_OmitNoopJoin 0x0400 14055 #define SQLITE_Stat34 0x0800 14056 #define SQLITE_CursorHints 0x2000 14057 #define SQLITE_AllOpts 0xffff 14062 #ifndef SQLITE_OMIT_BUILTIN_TEST 14063 #define OptimizationDisabled(db, mask) (((db)->dbOptFlags&(mask))!=0) 14064 #define OptimizationEnabled(db, mask) (((db)->dbOptFlags&(mask))==0) 14066 #define OptimizationDisabled(db, mask) 0 14067 #define OptimizationEnabled(db, mask) 1 14074 #define ConstFactorOk(P) ((P)->okConstFactor) 14081 #define SQLITE_MAGIC_OPEN 0xa029a697 14082 #define SQLITE_MAGIC_CLOSED 0x9f3c2d33 14083 #define SQLITE_MAGIC_SICK 0x4b771290 14084 #define SQLITE_MAGIC_BUSY 0xf03b7906 14085 #define SQLITE_MAGIC_ERROR 0xb5357930 14086 #define SQLITE_MAGIC_ZOMBIE 0x64cffc7f 14108 FuncDestructor *pDestructor;
14126 struct FuncDestructor {
14128 void (*xDestroy)(
void *);
14145 #define SQLITE_FUNC_ENCMASK 0x0003 14146 #define SQLITE_FUNC_LIKE 0x0004 14147 #define SQLITE_FUNC_CASE 0x0008 14148 #define SQLITE_FUNC_EPHEM 0x0010 14149 #define SQLITE_FUNC_NEEDCOLL 0x0020 14150 #define SQLITE_FUNC_LENGTH 0x0040 14151 #define SQLITE_FUNC_TYPEOF 0x0080 14152 #define SQLITE_FUNC_COUNT 0x0100 14153 #define SQLITE_FUNC_COALESCE 0x0200 14154 #define SQLITE_FUNC_UNLIKELY 0x0400 14155 #define SQLITE_FUNC_CONSTANT 0x0800 14156 #define SQLITE_FUNC_MINMAX 0x1000 14157 #define SQLITE_FUNC_SLOCHNG 0x2000 14194 #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \ 14195 {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \ 14196 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, {0} } 14197 #define VFUNCTION(zName, nArg, iArg, bNC, xFunc) \ 14198 {nArg, SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \ 14199 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, {0} } 14200 #define DFUNCTION(zName, nArg, iArg, bNC, xFunc) \ 14201 {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \ 14202 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, {0} } 14203 #define FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags) \ 14204 {nArg,SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL)|extraFlags,\ 14205 SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, {0} } 14206 #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \ 14207 {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \ 14208 pArg, 0, xFunc, 0, #zName, } 14209 #define LIKEFUNC(zName, nArg, arg, flags) \ 14210 {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|flags, \ 14211 (void *)arg, 0, likeFunc, 0, #zName, {0} } 14212 #define AGGREGATE(zName, nArg, arg, nc, xStep, xFinal) \ 14213 {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL), \ 14214 SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,#zName, {0}} 14215 #define AGGREGATE2(zName, nArg, arg, nc, xStep, xFinal, extraFlags) \ 14216 {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL)|extraFlags, \ 14217 SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,#zName, {0}} 14228 i64 nDeferredImmCons;
14236 #define SAVEPOINT_BEGIN 0 14237 #define SAVEPOINT_RELEASE 1 14238 #define SAVEPOINT_ROLLBACK 2 14250 void (*xDestroy)(
void *);
14270 #define COLFLAG_PRIMKEY 0x0001 14271 #define COLFLAG_HIDDEN 0x0002 14272 #define COLFLAG_HASTYPE 0x0004 14287 int (*xCmp)(
void*,int,
const void*, int,
const void*);
14288 void (*xDel)(
void*);
14294 #define SQLITE_SO_ASC 0 14295 #define SQLITE_SO_DESC 1 14296 #define SQLITE_SO_UNDEFINED -1 14312 #define SQLITE_AFF_BLOB 'A' 14313 #define SQLITE_AFF_TEXT 'B' 14314 #define SQLITE_AFF_NUMERIC 'C' 14315 #define SQLITE_AFF_INTEGER 'D' 14316 #define SQLITE_AFF_REAL 'E' 14318 #define sqlite3IsNumericAffinity(X) ((X)>=SQLITE_AFF_NUMERIC) 14324 #define SQLITE_AFF_MASK 0x47 14335 #define SQLITE_JUMPIFNULL 0x10 14336 #define SQLITE_STOREP2 0x20 14337 #define SQLITE_NULLEQ 0x80 14338 #define SQLITE_NOTNULL 0x90 14411 #ifdef SQLITE_ENABLE_COSTMULT 14416 #ifndef SQLITE_OMIT_ALTERTABLE 14419 #ifndef SQLITE_OMIT_VIRTUALTABLE 14421 char **azModuleArg;
14426 Table *pNextZombie;
14438 #define TF_Readonly 0x01 14439 #define TF_Ephemeral 0x02 14440 #define TF_HasPrimaryKey 0x04 14441 #define TF_Autoincrement 0x08 14442 #define TF_Virtual 0x10 14443 #define TF_WithoutRowid 0x20 14444 #define TF_NoVisibleRowid 0x40 14445 #define TF_OOOHidden 0x80 14453 #ifndef SQLITE_OMIT_VIRTUALTABLE 14454 # define IsVirtual(X) (((X)->tabFlags & TF_Virtual)!=0) 14456 # define IsVirtual(X) 0 14465 #if defined(SQLITE_ENABLE_HIDDEN_COLUMNS) 14466 # define IsHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0) 14467 # define IsOrdinaryHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0) 14468 #elif !defined(SQLITE_OMIT_VIRTUALTABLE) 14469 # define IsHiddenColumn(X) (((X)->colFlags & COLFLAG_HIDDEN)!=0) 14470 # define IsOrdinaryHiddenColumn(X) 0 14472 # define IsHiddenColumn(X) 0 14473 # define IsOrdinaryHiddenColumn(X) 0 14478 #define HasRowid(X) (((X)->tabFlags & TF_WithoutRowid)==0) 14479 #define VisibleRowid(X) (((X)->tabFlags & TF_NoVisibleRowid)==0) 14519 Trigger *apTrigger[2];
14552 #define OE_Rollback 1 14555 #define OE_Ignore 4 14556 #define OE_Replace 5 14558 #define OE_Restrict 6 14559 #define OE_SetNull 7 14560 #define OE_SetDflt 8 14561 #define OE_Cascade 9 14563 #define OE_Default 10 14620 struct UnpackedRecord {
14669 LogEst *aiRowLogEst;
14675 const char **azColl;
14676 Expr *pPartIdxWhere;
14677 ExprList *aColExpr;
14683 unsigned idxType:2;
14684 unsigned bUnordered:1;
14685 unsigned uniqNotNull:1;
14686 unsigned isResized:1;
14687 unsigned isCovering:1;
14688 unsigned noSkipScan:1;
14689 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4 14693 IndexSample *aSample;
14702 #define SQLITE_IDXTYPE_APPDEF 0 14703 #define SQLITE_IDXTYPE_UNIQUE 1 14704 #define SQLITE_IDXTYPE_PRIMARYKEY 2 14707 #define IsPrimaryKeyIndex(X) ((X)->idxType==SQLITE_IDXTYPE_PRIMARYKEY) 14710 #define IsUniqueIndex(X) ((X)->onError!=OE_None) 14715 #define XN_ROWID (-1) 14716 #define XN_EXPR (-2) 14723 struct IndexSample {
14763 int sortingIdxPTab;
14764 int nSortingColumn;
14766 ExprList *pGroupBy;
14798 #if SQLITE_MAX_VARIABLE_NUMBER<=32767 14893 #if SQLITE_MAX_EXPR_DEPTH>0 14903 i16 iRightJoinTable;
14914 #define EP_FromJoin 0x000001 14915 #define EP_Agg 0x000002 14916 #define EP_Resolved 0x000004 14917 #define EP_Error 0x000008 14918 #define EP_Distinct 0x000010 14919 #define EP_VarSelect 0x000020 14920 #define EP_DblQuoted 0x000040 14921 #define EP_InfixFunc 0x000080 14922 #define EP_Collate 0x000100 14923 #define EP_Generic 0x000200 14924 #define EP_IntValue 0x000400 14925 #define EP_xIsSelect 0x000800 14926 #define EP_Skip 0x001000 14927 #define EP_Reduced 0x002000 14928 #define EP_TokenOnly 0x004000 14929 #define EP_Static 0x008000 14930 #define EP_MemToken 0x010000 14931 #define EP_NoReduce 0x020000 14932 #define EP_Unlikely 0x040000 14933 #define EP_ConstFunc 0x080000 14934 #define EP_CanBeNull 0x100000 14935 #define EP_Subquery 0x200000 14936 #define EP_Alias 0x400000 14941 #define EP_Propagate (EP_Collate|EP_Subquery) 14947 #define ExprHasProperty(E,P) (((E)->flags&(P))!=0) 14948 #define ExprHasAllProperty(E,P) (((E)->flags&(P))==(P)) 14949 #define ExprSetProperty(E,P) (E)->flags|=(P) 14950 #define ExprClearProperty(E,P) (E)->flags&=~(P) 14956 #ifdef SQLITE_DEBUG 14957 # define ExprSetVVAProperty(E,P) (E)->flags|=(P) 14959 # define ExprSetVVAProperty(E,P) 14967 #define EXPR_FULLSIZE sizeof(Expr) 14968 #define EXPR_REDUCEDSIZE offsetof(Expr,iTable) 14969 #define EXPR_TOKENONLYSIZE offsetof(Expr,pLeft) 14975 #define EXPRDUP_REDUCE 0x0001 15001 unsigned bSpanIsTab :1;
15002 unsigned reusable :1;
15020 const char *zStart;
15054 #ifdef SQLITE_BITMASK_TYPE 15055 typedef SQLITE_BITMASK_TYPE Bitmask;
15057 typedef u64 Bitmask;
15063 #define BMS ((int)(sizeof(Bitmask)*8)) 15068 #define MASKBIT(n) (((Bitmask)1)<<(n)) 15069 #define MASKBIT32(n) (((unsigned int)1)<<(n)) 15070 #define ALLBITS ((Bitmask)-1) 15106 unsigned notIndexed :1;
15107 unsigned isIndexedBy :1;
15108 unsigned isTabFunc :1;
15109 unsigned isCorrelated :1;
15110 unsigned viaCoroutine :1;
15111 unsigned isRecursive :1;
15113 #ifndef SQLITE_OMIT_EXPLAIN 15122 ExprList *pFuncArg;
15131 #define JT_INNER 0x0001 15132 #define JT_CROSS 0x0002 15133 #define JT_NATURAL 0x0004 15134 #define JT_LEFT 0x0008 15135 #define JT_RIGHT 0x0010 15136 #define JT_OUTER 0x0020 15137 #define JT_ERROR 0x0040 15147 #define WHERE_ORDERBY_NORMAL 0x0000 15148 #define WHERE_ORDERBY_MIN 0x0001 15149 #define WHERE_ORDERBY_MAX 0x0002 15150 #define WHERE_ONEPASS_DESIRED 0x0004 15151 #define WHERE_ONEPASS_MULTIROW 0x0008 15152 #define WHERE_DUPLICATES_OK 0x0010 15153 #define WHERE_OR_SUBCLAUSE 0x0020 15155 #define WHERE_GROUPBY 0x0040 15156 #define WHERE_DISTINCTBY 0x0080 15157 #define WHERE_WANT_DISTINCT 0x0100 15158 #define WHERE_SORTBYGROUP 0x0200 15159 #define WHERE_SEEK_TABLE 0x0400 15160 #define WHERE_ORDERBY_LIMIT 0x0800 15163 #define WHERE_USE_LIMIT 0x4000 15168 #define WHERE_DISTINCT_NOOP 0 15169 #define WHERE_DISTINCT_UNIQUE 1 15170 #define WHERE_DISTINCT_ORDERED 2 15171 #define WHERE_DISTINCT_UNORDERED 3 15194 struct NameContext {
15199 NameContext *pNext;
15213 #define NC_AllowAgg 0x0001 15214 #define NC_PartIdx 0x0002 15215 #define NC_IsCheck 0x0004 15216 #define NC_InAggFunc 0x0008 15217 #define NC_HasAgg 0x0010 15218 #define NC_IdxExpr 0x0020 15219 #define NC_VarSelect 0x0040 15220 #define NC_MinMaxAgg 0x1000 15247 int iLimit, iOffset;
15248 #if SELECTTRACE_ENABLED 15251 int addrOpenEphm[2];
15254 ExprList *pGroupBy;
15256 ExprList *pOrderBy;
15273 #define SF_Distinct 0x00001 15274 #define SF_All 0x00002 15275 #define SF_Resolved 0x00004 15276 #define SF_Aggregate 0x00008 15277 #define SF_HasAgg 0x00010 15278 #define SF_UsesEphemeral 0x00020 15279 #define SF_Expanded 0x00040 15280 #define SF_HasTypeInfo 0x00080 15281 #define SF_Compound 0x00100 15282 #define SF_Values 0x00200 15283 #define SF_MultiValue 0x00400 15284 #define SF_NestedFrom 0x00800 15285 #define SF_MinMaxAgg 0x01000 15286 #define SF_Recursive 0x02000 15287 #define SF_FixedLimit 0x04000 15288 #define SF_MaybeConvert 0x08000 15289 #define SF_Converted 0x10000 15290 #define SF_IncludeHidden 0x20000 15357 #define SRT_Union 1 15358 #define SRT_Except 2 15359 #define SRT_Exists 3 15360 #define SRT_Discard 4 15362 #define SRT_DistFifo 6 15363 #define SRT_Queue 7 15364 #define SRT_DistQueue 8 15367 #define IgnorableOrderby(X) ((X->eDest)<=SRT_DistQueue) 15369 #define SRT_Output 9 15372 #define SRT_EphemTab 12 15373 #define SRT_Coroutine 13 15374 #define SRT_Table 14 15380 struct SelectDest {
15386 ExprList *pOrderBy;
15398 struct AutoincInfo {
15399 AutoincInfo *pNext;
15408 #ifndef SQLITE_N_COLCACHE 15409 # define SQLITE_N_COLCACHE 10 15430 struct TriggerPrg {
15433 SubProgram *pProgram;
15441 #if SQLITE_MAX_ATTACHED>30 15442 typedef unsigned char yDbMask[(SQLITE_MAX_ATTACHED+9)/8];
15443 # define DbMaskTest(M,I) (((M)[(I)/8]&(1<<((I)&7)))!=0) 15444 # define DbMaskZero(M) memset((M),0,sizeof(M)) 15445 # define DbMaskSet(M,I) (M)[(I)/8]|=(1<<((I)&7)) 15446 # define DbMaskAllZero(M) sqlite3DbMaskAllZero(M) 15447 # define DbMaskNonZero(M) (sqlite3DbMaskAllZero(M)==0) 15449 typedef unsigned int yDbMask;
15450 # define DbMaskTest(M,I) (((M)&(((yDbMask)1)<<(I)))!=0) 15451 # define DbMaskZero(M) (M)=0 15452 # define DbMaskSet(M,I) (M)|=(((yDbMask)1)<<(I)) 15453 # define DbMaskAllZero(M) (M)==0 15454 # define DbMaskNonZero(M) (M)!=0 15486 u8 disableLookaside;
15512 } aColCache[SQLITE_N_COLCACHE];
15513 ExprList *pConstExpr;
15514 Token constraintName;
15516 yDbMask cookieMask;
15517 int cookieValue[SQLITE_MAX_ATTACHED+2];
15521 #if SELECTTRACE_ENABLED 15525 #ifndef SQLITE_OMIT_SHARED_CACHE 15527 TableLock *aTableLock;
15529 AutoincInfo *pAinc;
15533 Table *pTriggerTab;
15540 u8 disableTriggers;
15553 #ifndef SQLITE_OMIT_VIRTUALTABLE 15559 #ifndef SQLITE_OMIT_EXPLAIN 15567 Trigger *pNewTrigger;
15568 const char *zAuthContext;
15571 #ifndef SQLITE_OMIT_VIRTUALTABLE 15573 Table **apVtabLock;
15576 TriggerPrg *pTriggerPrg;
15584 #ifdef SQLITE_OMIT_VIRTUALTABLE 15585 #define IN_DECLARE_VTAB 0 15587 #define IN_DECLARE_VTAB (pParse->declareVtab) 15594 struct AuthContext {
15595 const char *zAuthContext;
15611 #define OPFLAG_NCHANGE 0x01 15613 #define OPFLAG_EPHEM 0x01 15614 #define OPFLAG_LASTROWID 0x02 15615 #define OPFLAG_ISUPDATE 0x04 15616 #define OPFLAG_APPEND 0x08 15617 #define OPFLAG_USESEEKRESULT 0x10 15618 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK 15619 #define OPFLAG_ISNOOP 0x40 15621 #define OPFLAG_LENGTHARG 0x40 15622 #define OPFLAG_TYPEOFARG 0x80 15623 #define OPFLAG_BULKCSR 0x01 15624 #define OPFLAG_SEEKEQ 0x02 15625 #define OPFLAG_FORDELETE 0x08 15626 #define OPFLAG_P2ISREG 0x10 15627 #define OPFLAG_PERMUTE 0x01 15628 #define OPFLAG_SAVEPOSITION 0x02 15629 #define OPFLAG_AUXDELETE 0x04 15655 Schema *pTabSchema;
15656 TriggerStep *step_list;
15667 #define TRIGGER_BEFORE 1 15668 #define TRIGGER_AFTER 2 15708 struct TriggerStep {
15715 ExprList *pExprList;
15717 TriggerStep *pNext;
15718 TriggerStep *pLast;
15726 typedef struct DbFixer DbFixer;
15733 const Token *pName;
15750 #define STRACCUM_NOMEM 1 15751 #define STRACCUM_TOOBIG 2 15752 #define SQLITE_PRINTF_INTERNAL 0x01 15753 #define SQLITE_PRINTF_SQLFUNC 0x02 15754 #define SQLITE_PRINTF_MALLOCED 0x04 15756 #define isMalloced(X) (((X)->printfFlags & SQLITE_PRINTF_MALLOCED)!=0) 15792 sqlite3_int64 szMmap;
15793 sqlite3_int64 mxMmap;
15801 int sharedCacheEnabled;
15812 void (*xLog)(
void*,int,
const char*);
15814 #ifdef SQLITE_ENABLE_SQLLOG 15815 void(*xSqllog)(
void*,
sqlite3*,
const char*, int);
15818 #ifdef SQLITE_VDBE_COVERAGE 15822 void (*xVdbeBranch)(
void*,
int iSrcLine,u8 eThis,u8 eMx);
15823 void *pVdbeBranchArg;
15825 #ifndef SQLITE_OMIT_BUILTIN_TEST 15826 int (*xTestCallback)(int);
15828 int bLocaltimeFault;
15847 #define CORRUPT_DB (sqlite3Config.neverCorrupt==0) 15854 int (*xExprCallback)(Walker*, Expr*);
15855 int (*xSelectCallback)(Walker*,Select*);
15856 void (*xSelectCallback2)(Walker*,Select*);
15865 struct CCurHint *pCCurHint;
15872 SQLITE_PRIVATE
int sqlite3WalkExpr(Walker*, Expr*);
15873 SQLITE_PRIVATE
int sqlite3WalkExprList(Walker*, ExprList*);
15874 SQLITE_PRIVATE
int sqlite3WalkSelect(Walker*, Select*);
15875 SQLITE_PRIVATE
int sqlite3WalkSelectExpr(Walker*, Select*);
15876 SQLITE_PRIVATE
int sqlite3WalkSelectFrom(Walker*, Select*);
15877 SQLITE_PRIVATE
int sqlite3ExprWalkNoop(Walker*, Expr*);
15883 #define WRC_Continue 0 15884 #define WRC_Prune 1 15885 #define WRC_Abort 2 15898 const char *zCteErr;
15902 #ifdef SQLITE_DEBUG 15917 #define SQLITE_SKIP_UTF8(zIn) { \ 15918 if( (*(zIn++))>=0xc0 ){ \ 15919 while( (*zIn & 0xc0)==0x80 ){ zIn++; } \ 15930 SQLITE_PRIVATE
int sqlite3CorruptError(
int);
15931 SQLITE_PRIVATE
int sqlite3MisuseError(
int);
15932 SQLITE_PRIVATE
int sqlite3CantopenError(
int);
15933 #define SQLITE_CORRUPT_BKPT sqlite3CorruptError(__LINE__) 15934 #define SQLITE_MISUSE_BKPT sqlite3MisuseError(__LINE__) 15935 #define SQLITE_CANTOPEN_BKPT sqlite3CantopenError(__LINE__) 15936 #ifdef SQLITE_DEBUG 15937 SQLITE_PRIVATE
int sqlite3NomemError(
int);
15938 SQLITE_PRIVATE
int sqlite3IoerrnomemError(
int);
15939 # define SQLITE_NOMEM_BKPT sqlite3NomemError(__LINE__) 15940 # define SQLITE_IOERR_NOMEM_BKPT sqlite3IoerrnomemError(__LINE__) 15942 # define SQLITE_NOMEM_BKPT SQLITE_NOMEM 15943 # define SQLITE_IOERR_NOMEM_BKPT SQLITE_IOERR_NOMEM 15949 #if defined(SQLITE_OMIT_VIRTUALTABLE) 15950 # undef SQLITE_ENABLE_FTS3 15951 # undef SQLITE_ENABLE_FTS4 15959 #if defined(SQLITE_ENABLE_FTS4) && !defined(SQLITE_ENABLE_FTS3) 15960 # define SQLITE_ENABLE_FTS3 1 15967 #if !defined(SQLITE_ASCII) || \ 15968 (defined(SQLITE_ENABLE_FTS3) && defined(SQLITE_AMALGAMATION)) 15969 # include <ctype.h> 15977 #ifdef SQLITE_ASCII 15978 # define sqlite3Toupper(x) ((x)&~(sqlite3CtypeMap[(unsigned char)(x)]&0x20)) 15979 # define sqlite3Isspace(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x01) 15980 # define sqlite3Isalnum(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x06) 15981 # define sqlite3Isalpha(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x02) 15982 # define sqlite3Isdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x04) 15983 # define sqlite3Isxdigit(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x08) 15984 # define sqlite3Tolower(x) (sqlite3UpperToLower[(unsigned char)(x)]) 15985 # define sqlite3Isquote(x) (sqlite3CtypeMap[(unsigned char)(x)]&0x80) 15987 # define sqlite3Toupper(x) toupper((unsigned char)(x)) 15988 # define sqlite3Isspace(x) isspace((unsigned char)(x)) 15989 # define sqlite3Isalnum(x) isalnum((unsigned char)(x)) 15990 # define sqlite3Isalpha(x) isalpha((unsigned char)(x)) 15991 # define sqlite3Isdigit(x) isdigit((unsigned char)(x)) 15992 # define sqlite3Isxdigit(x) isxdigit((unsigned char)(x)) 15993 # define sqlite3Tolower(x) tolower((unsigned char)(x)) 15994 # define sqlite3Isquote(x) ((x)=='"'||(x)=='\''||(x)=='['||(x)=='`') 15996 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS 15997 SQLITE_PRIVATE
int sqlite3IsIdChar(u8);
16003 SQLITE_PRIVATE
int sqlite3StrICmp(
const char*,
const char*);
16004 SQLITE_PRIVATE
int sqlite3Strlen30(
const char*);
16005 SQLITE_PRIVATE
char *sqlite3ColumnType(Column*,
char*);
16006 #define sqlite3StrNICmp sqlite3_strnicmp 16008 SQLITE_PRIVATE
int sqlite3MallocInit(
void);
16009 SQLITE_PRIVATE
void sqlite3MallocEnd(
void);
16010 SQLITE_PRIVATE
void *sqlite3Malloc(u64);
16011 SQLITE_PRIVATE
void *sqlite3MallocZero(u64);
16012 SQLITE_PRIVATE
void *sqlite3DbMallocZero(
sqlite3*, u64);
16013 SQLITE_PRIVATE
void *sqlite3DbMallocRaw(
sqlite3*, u64);
16014 SQLITE_PRIVATE
void *sqlite3DbMallocRawNN(
sqlite3*, u64);
16015 SQLITE_PRIVATE
char *sqlite3DbStrDup(
sqlite3*,
const char*);
16016 SQLITE_PRIVATE
char *sqlite3DbStrNDup(
sqlite3*,
const char*, u64);
16017 SQLITE_PRIVATE
void *sqlite3Realloc(
void*, u64);
16018 SQLITE_PRIVATE
void *sqlite3DbReallocOrFree(
sqlite3 *,
void *, u64);
16019 SQLITE_PRIVATE
void *sqlite3DbRealloc(
sqlite3 *,
void *, u64);
16020 SQLITE_PRIVATE
void sqlite3DbFree(
sqlite3*,
void*);
16021 SQLITE_PRIVATE
int sqlite3MallocSize(
void*);
16022 SQLITE_PRIVATE
int sqlite3DbMallocSize(
sqlite3*,
void*);
16023 SQLITE_PRIVATE
void *sqlite3ScratchMalloc(
int);
16024 SQLITE_PRIVATE
void sqlite3ScratchFree(
void*);
16025 SQLITE_PRIVATE
void *sqlite3PageMalloc(
int);
16026 SQLITE_PRIVATE
void sqlite3PageFree(
void*);
16027 SQLITE_PRIVATE
void sqlite3MemSetDefault(
void);
16028 #ifndef SQLITE_OMIT_BUILTIN_TEST 16029 SQLITE_PRIVATE
void sqlite3BenignMallocHooks(
void (*)(
void),
void (*)(
void));
16031 SQLITE_PRIVATE
int sqlite3HeapNearlyFull(
void);
16041 #ifdef SQLITE_USE_ALLOCA 16042 # define sqlite3StackAllocRaw(D,N) alloca(N) 16043 # define sqlite3StackAllocZero(D,N) memset(alloca(N), 0, N) 16044 # define sqlite3StackFree(D,P) 16046 # define sqlite3StackAllocRaw(D,N) sqlite3DbMallocRaw(D,N) 16047 # define sqlite3StackAllocZero(D,N) sqlite3DbMallocZero(D,N) 16048 # define sqlite3StackFree(D,P) sqlite3DbFree(D,P) 16054 #ifdef SQLITE_ENABLE_MEMSYS5 16056 #undef SQLITE_ENABLE_MEMSYS3 16058 #ifdef SQLITE_ENABLE_MEMSYS3 16063 #ifndef SQLITE_MUTEX_OMIT 16067 SQLITE_PRIVATE
int sqlite3MutexInit(
void);
16068 SQLITE_PRIVATE
int sqlite3MutexEnd(
void);
16070 #if !defined(SQLITE_MUTEX_OMIT) && !defined(SQLITE_MUTEX_NOOP) 16071 SQLITE_PRIVATE
void sqlite3MemoryBarrier(
void);
16073 # define sqlite3MemoryBarrier() 16076 SQLITE_PRIVATE sqlite3_int64 sqlite3StatusValue(
int);
16077 SQLITE_PRIVATE
void sqlite3StatusUp(
int,
int);
16078 SQLITE_PRIVATE
void sqlite3StatusDown(
int,
int);
16079 SQLITE_PRIVATE
void sqlite3StatusHighwater(
int,
int);
16085 #ifndef SQLITE_OMIT_FLOATING_POINT 16086 SQLITE_PRIVATE
int sqlite3IsNaN(
double);
16088 # define sqlite3IsNaN(X) 0 16095 struct PrintfArguments {
16101 SQLITE_PRIVATE
void sqlite3VXPrintf(StrAccum*,
const char*, va_list);
16102 SQLITE_PRIVATE
void sqlite3XPrintf(StrAccum*,
const char*, ...);
16103 SQLITE_PRIVATE
char *sqlite3MPrintf(
sqlite3*,
const char*, ...);
16104 SQLITE_PRIVATE
char *sqlite3VMPrintf(
sqlite3*,
const char*, va_list);
16105 #if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE) 16106 SQLITE_PRIVATE
void sqlite3DebugPrintf(
const char*, ...);
16108 #if defined(SQLITE_TEST) 16109 SQLITE_PRIVATE
void *sqlite3TestTextToPtr(
const char*);
16112 #if defined(SQLITE_DEBUG) 16113 SQLITE_PRIVATE
void sqlite3TreeViewExpr(TreeView*,
const Expr*, u8);
16114 SQLITE_PRIVATE
void sqlite3TreeViewExprList(TreeView*,
const ExprList*, u8,
const char*);
16115 SQLITE_PRIVATE
void sqlite3TreeViewSelect(TreeView*,
const Select*, u8);
16116 SQLITE_PRIVATE
void sqlite3TreeViewWith(TreeView*,
const With*, u8);
16120 SQLITE_PRIVATE
void sqlite3SetString(
char **,
sqlite3*,
const char*);
16121 SQLITE_PRIVATE
void sqlite3ErrorMsg(Parse*,
const char*, ...);
16122 SQLITE_PRIVATE
void sqlite3Dequote(
char*);
16123 SQLITE_PRIVATE
void sqlite3TokenInit(Token*,
char*);
16124 SQLITE_PRIVATE
int sqlite3KeywordCode(
const unsigned char*,
int);
16125 SQLITE_PRIVATE
int sqlite3RunParser(Parse*,
const char*,
char **);
16126 SQLITE_PRIVATE
void sqlite3FinishCoding(Parse*);
16127 SQLITE_PRIVATE
int sqlite3GetTempReg(Parse*);
16128 SQLITE_PRIVATE
void sqlite3ReleaseTempReg(Parse*,
int);
16129 SQLITE_PRIVATE
int sqlite3GetTempRange(Parse*,
int);
16130 SQLITE_PRIVATE
void sqlite3ReleaseTempRange(Parse*,
int,
int);
16131 SQLITE_PRIVATE
void sqlite3ClearTempRegCache(Parse*);
16132 #ifdef SQLITE_DEBUG 16133 SQLITE_PRIVATE
int sqlite3NoTempsInRange(Parse*,
int,
int);
16135 SQLITE_PRIVATE Expr *sqlite3ExprAlloc(
sqlite3*,
int,
const Token*,
int);
16136 SQLITE_PRIVATE Expr *sqlite3Expr(
sqlite3*,
int,
const char*);
16137 SQLITE_PRIVATE
void sqlite3ExprAttachSubtrees(
sqlite3*,Expr*,Expr*,Expr*);
16138 SQLITE_PRIVATE Expr *sqlite3PExpr(Parse*,
int, Expr*, Expr*,
const Token*);
16139 SQLITE_PRIVATE
void sqlite3PExprAddSelect(Parse*, Expr*, Select*);
16140 SQLITE_PRIVATE Expr *sqlite3ExprAnd(
sqlite3*,Expr*, Expr*);
16141 SQLITE_PRIVATE Expr *sqlite3ExprFunction(Parse*,ExprList*, Token*);
16142 SQLITE_PRIVATE
void sqlite3ExprAssignVarNumber(Parse*, Expr*);
16143 SQLITE_PRIVATE
void sqlite3ExprDelete(
sqlite3*, Expr*);
16144 SQLITE_PRIVATE ExprList *sqlite3ExprListAppend(Parse*,ExprList*,Expr*);
16145 SQLITE_PRIVATE
void sqlite3ExprListSetSortOrder(ExprList*,
int);
16146 SQLITE_PRIVATE
void sqlite3ExprListSetName(Parse*,ExprList*,Token*,
int);
16147 SQLITE_PRIVATE
void sqlite3ExprListSetSpan(Parse*,ExprList*,ExprSpan*);
16148 SQLITE_PRIVATE
void sqlite3ExprListDelete(
sqlite3*, ExprList*);
16149 SQLITE_PRIVATE u32 sqlite3ExprListFlags(
const ExprList*);
16150 SQLITE_PRIVATE
int sqlite3Init(
sqlite3*,
char**);
16151 SQLITE_PRIVATE
int sqlite3InitCallback(
void*,
int,
char**,
char**);
16152 SQLITE_PRIVATE
void sqlite3Pragma(Parse*,Token*,Token*,Token*,
int);
16153 SQLITE_PRIVATE
void sqlite3ResetAllSchemasOfConnection(
sqlite3*);
16154 SQLITE_PRIVATE
void sqlite3ResetOneSchema(
sqlite3*,
int);
16155 SQLITE_PRIVATE
void sqlite3CollapseDatabaseArray(
sqlite3*);
16156 SQLITE_PRIVATE
void sqlite3CommitInternalChanges(
sqlite3*);
16157 SQLITE_PRIVATE
void sqlite3DeleteColumnNames(
sqlite3*,Table*);
16158 SQLITE_PRIVATE
int sqlite3ColumnsFromExprList(Parse*,ExprList*,i16*,Column**);
16159 SQLITE_PRIVATE
void sqlite3SelectAddColumnTypeAndCollation(Parse*,Table*,Select*);
16160 SQLITE_PRIVATE Table *sqlite3ResultSetOfSelect(Parse*,Select*);
16161 SQLITE_PRIVATE
void sqlite3OpenMasterTable(Parse *,
int);
16162 SQLITE_PRIVATE Index *sqlite3PrimaryKeyIndex(Table*);
16163 SQLITE_PRIVATE i16 sqlite3ColumnOfIndex(Index*, i16);
16164 SQLITE_PRIVATE
void sqlite3StartTable(Parse*,Token*,Token*,
int,
int,
int,
int);
16165 #if SQLITE_ENABLE_HIDDEN_COLUMNS 16166 SQLITE_PRIVATE
void sqlite3ColumnPropertiesFromName(Table*, Column*);
16168 # define sqlite3ColumnPropertiesFromName(T,C) 16170 SQLITE_PRIVATE
void sqlite3AddColumn(Parse*,Token*,Token*);
16171 SQLITE_PRIVATE
void sqlite3AddNotNull(Parse*,
int);
16172 SQLITE_PRIVATE
void sqlite3AddPrimaryKey(Parse*, ExprList*,
int,
int,
int);
16173 SQLITE_PRIVATE
void sqlite3AddCheckConstraint(Parse*, Expr*);
16174 SQLITE_PRIVATE
void sqlite3AddDefaultValue(Parse*,ExprSpan*);
16175 SQLITE_PRIVATE
void sqlite3AddCollateType(Parse*, Token*);
16176 SQLITE_PRIVATE
void sqlite3EndTable(Parse*,Token*,Token*,u8,Select*);
16177 SQLITE_PRIVATE
int sqlite3ParseUri(
const char*,
const char*,
unsigned int*,
16179 SQLITE_PRIVATE Btree *sqlite3DbNameToBtree(
sqlite3*,
const char*);
16180 SQLITE_PRIVATE
int sqlite3CodeOnce(Parse *);
16182 #ifdef SQLITE_OMIT_BUILTIN_TEST 16183 # define sqlite3FaultSim(X) SQLITE_OK 16185 SQLITE_PRIVATE
int sqlite3FaultSim(
int);
16188 SQLITE_PRIVATE Bitvec *sqlite3BitvecCreate(u32);
16189 SQLITE_PRIVATE
int sqlite3BitvecTest(Bitvec*, u32);
16190 SQLITE_PRIVATE
int sqlite3BitvecTestNotNull(Bitvec*, u32);
16191 SQLITE_PRIVATE
int sqlite3BitvecSet(Bitvec*, u32);
16192 SQLITE_PRIVATE
void sqlite3BitvecClear(Bitvec*, u32,
void*);
16193 SQLITE_PRIVATE
void sqlite3BitvecDestroy(Bitvec*);
16194 SQLITE_PRIVATE u32 sqlite3BitvecSize(Bitvec*);
16195 #ifndef SQLITE_OMIT_BUILTIN_TEST 16196 SQLITE_PRIVATE
int sqlite3BitvecBuiltinTest(
int,
int*);
16199 SQLITE_PRIVATE RowSet *sqlite3RowSetInit(
sqlite3*,
void*,
unsigned int);
16200 SQLITE_PRIVATE
void sqlite3RowSetClear(RowSet*);
16201 SQLITE_PRIVATE
void sqlite3RowSetInsert(RowSet*, i64);
16202 SQLITE_PRIVATE
int sqlite3RowSetTest(RowSet*,
int iBatch, i64);
16203 SQLITE_PRIVATE
int sqlite3RowSetNext(RowSet*, i64*);
16205 SQLITE_PRIVATE
void sqlite3CreateView(Parse*,Token*,Token*,Token*,ExprList*,Select*,
int,
int);
16207 #if !defined(SQLITE_OMIT_VIEW) || !defined(SQLITE_OMIT_VIRTUALTABLE) 16208 SQLITE_PRIVATE
int sqlite3ViewGetColumnNames(Parse*,Table*);
16210 # define sqlite3ViewGetColumnNames(A,B) 0 16213 #if SQLITE_MAX_ATTACHED>30 16214 SQLITE_PRIVATE
int sqlite3DbMaskAllZero(yDbMask);
16216 SQLITE_PRIVATE
void sqlite3DropTable(Parse*, SrcList*,
int,
int);
16217 SQLITE_PRIVATE
void sqlite3CodeDropTable(Parse*, Table*,
int,
int);
16218 SQLITE_PRIVATE
void sqlite3DeleteTable(
sqlite3*, Table*);
16219 #ifndef SQLITE_OMIT_AUTOINCREMENT 16220 SQLITE_PRIVATE
void sqlite3AutoincrementBegin(Parse *pParse);
16221 SQLITE_PRIVATE
void sqlite3AutoincrementEnd(Parse *pParse);
16223 # define sqlite3AutoincrementBegin(X) 16224 # define sqlite3AutoincrementEnd(X) 16226 SQLITE_PRIVATE
void sqlite3Insert(Parse*, SrcList*, Select*, IdList*,
int);
16227 SQLITE_PRIVATE
void *sqlite3ArrayAllocate(
sqlite3*,
void*,
int,
int*,
int*);
16228 SQLITE_PRIVATE IdList *sqlite3IdListAppend(
sqlite3*, IdList*, Token*);
16229 SQLITE_PRIVATE
int sqlite3IdListIndex(IdList*,
const char*);
16230 SQLITE_PRIVATE SrcList *sqlite3SrcListEnlarge(
sqlite3*, SrcList*,
int,
int);
16231 SQLITE_PRIVATE SrcList *sqlite3SrcListAppend(
sqlite3*, SrcList*, Token*, Token*);
16232 SQLITE_PRIVATE SrcList *sqlite3SrcListAppendFromTerm(Parse*, SrcList*, Token*, Token*,
16233 Token*, Select*, Expr*, IdList*);
16234 SQLITE_PRIVATE
void sqlite3SrcListIndexedBy(Parse *, SrcList *, Token *);
16235 SQLITE_PRIVATE
void sqlite3SrcListFuncArgs(Parse*, SrcList*, ExprList*);
16236 SQLITE_PRIVATE
int sqlite3IndexedByLookup(Parse *,
struct SrcList_item *);
16237 SQLITE_PRIVATE
void sqlite3SrcListShiftJoinType(SrcList*);
16238 SQLITE_PRIVATE
void sqlite3SrcListAssignCursors(Parse*, SrcList*);
16239 SQLITE_PRIVATE
void sqlite3IdListDelete(
sqlite3*, IdList*);
16240 SQLITE_PRIVATE
void sqlite3SrcListDelete(
sqlite3*, SrcList*);
16241 SQLITE_PRIVATE Index *sqlite3AllocateIndexObject(
sqlite3*,i16,
int,
char**);
16242 SQLITE_PRIVATE
void sqlite3CreateIndex(Parse*,Token*,Token*,SrcList*,ExprList*,
int,Token*,
16243 Expr*,
int,
int, u8);
16244 SQLITE_PRIVATE
void sqlite3DropIndex(Parse*, SrcList*,
int);
16245 SQLITE_PRIVATE
int sqlite3Select(Parse*, Select*, SelectDest*);
16246 SQLITE_PRIVATE Select *sqlite3SelectNew(Parse*,ExprList*,SrcList*,Expr*,ExprList*,
16247 Expr*,ExprList*,u32,Expr*,Expr*);
16248 SQLITE_PRIVATE
void sqlite3SelectDelete(
sqlite3*, Select*);
16249 SQLITE_PRIVATE Table *sqlite3SrcListLookup(Parse*, SrcList*);
16250 SQLITE_PRIVATE
int sqlite3IsReadOnly(Parse*, Table*,
int);
16251 SQLITE_PRIVATE
void sqlite3OpenTable(Parse*,
int iCur,
int iDb, Table*,
int);
16252 #if defined(SQLITE_ENABLE_UPDATE_DELETE_LIMIT) && !defined(SQLITE_OMIT_SUBQUERY) 16253 SQLITE_PRIVATE Expr *sqlite3LimitWhere(Parse*,SrcList*,Expr*,ExprList*,Expr*,Expr*,
char*);
16255 SQLITE_PRIVATE
void sqlite3DeleteFrom(Parse*, SrcList*, Expr*);
16256 SQLITE_PRIVATE
void sqlite3Update(Parse*, SrcList*, ExprList*, Expr*,
int);
16257 SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(Parse*,SrcList*,Expr*,ExprList*,ExprList*,u16,
int);
16258 SQLITE_PRIVATE
void sqlite3WhereEnd(WhereInfo*);
16259 SQLITE_PRIVATE LogEst sqlite3WhereOutputRowCount(WhereInfo*);
16260 SQLITE_PRIVATE
int sqlite3WhereIsDistinct(WhereInfo*);
16261 SQLITE_PRIVATE
int sqlite3WhereIsOrdered(WhereInfo*);
16262 SQLITE_PRIVATE
int sqlite3WhereOrderedInnerLoop(WhereInfo*);
16263 SQLITE_PRIVATE
int sqlite3WhereIsSorted(WhereInfo*);
16264 SQLITE_PRIVATE
int sqlite3WhereContinueLabel(WhereInfo*);
16265 SQLITE_PRIVATE
int sqlite3WhereBreakLabel(WhereInfo*);
16266 SQLITE_PRIVATE
int sqlite3WhereOkOnePass(WhereInfo*,
int*);
16267 #define ONEPASS_OFF 0 16268 #define ONEPASS_SINGLE 1 16269 #define ONEPASS_MULTI 2 16270 SQLITE_PRIVATE
void sqlite3ExprCodeLoadIndexColumn(Parse*, Index*,
int,
int,
int);
16271 SQLITE_PRIVATE
int sqlite3ExprCodeGetColumn(Parse*, Table*,
int,
int,
int, u8);
16272 SQLITE_PRIVATE
void sqlite3ExprCodeGetColumnToReg(Parse*, Table*,
int,
int,
int);
16273 SQLITE_PRIVATE
void sqlite3ExprCodeGetColumnOfTable(Vdbe*, Table*,
int,
int,
int);
16274 SQLITE_PRIVATE
void sqlite3ExprCodeMove(Parse*,
int,
int,
int);
16275 SQLITE_PRIVATE
void sqlite3ExprCacheStore(Parse*,
int,
int,
int);
16276 SQLITE_PRIVATE
void sqlite3ExprCachePush(Parse*);
16277 SQLITE_PRIVATE
void sqlite3ExprCachePop(Parse*);
16278 SQLITE_PRIVATE
void sqlite3ExprCacheRemove(Parse*,
int,
int);
16279 SQLITE_PRIVATE
void sqlite3ExprCacheClear(Parse*);
16280 SQLITE_PRIVATE
void sqlite3ExprCacheAffinityChange(Parse*,
int,
int);
16281 SQLITE_PRIVATE
void sqlite3ExprCode(Parse*, Expr*,
int);
16282 SQLITE_PRIVATE
void sqlite3ExprCodeCopy(Parse*, Expr*,
int);
16283 SQLITE_PRIVATE
void sqlite3ExprCodeFactorable(Parse*, Expr*,
int);
16284 SQLITE_PRIVATE
void sqlite3ExprCodeAtInit(Parse*, Expr*,
int, u8);
16285 SQLITE_PRIVATE
int sqlite3ExprCodeTemp(Parse*, Expr*,
int*);
16286 SQLITE_PRIVATE
int sqlite3ExprCodeTarget(Parse*, Expr*,
int);
16287 SQLITE_PRIVATE
void sqlite3ExprCodeAndCache(Parse*, Expr*,
int);
16288 SQLITE_PRIVATE
int sqlite3ExprCodeExprList(Parse*, ExprList*,
int,
int, u8);
16289 #define SQLITE_ECEL_DUP 0x01 16290 #define SQLITE_ECEL_FACTOR 0x02 16291 #define SQLITE_ECEL_REF 0x04 16292 SQLITE_PRIVATE
void sqlite3ExprIfTrue(Parse*, Expr*,
int,
int);
16293 SQLITE_PRIVATE
void sqlite3ExprIfFalse(Parse*, Expr*,
int,
int);
16294 SQLITE_PRIVATE
void sqlite3ExprIfFalseDup(Parse*, Expr*,
int,
int);
16295 SQLITE_PRIVATE Table *sqlite3FindTable(
sqlite3*,
const char*,
const char*);
16296 #define LOCATE_VIEW 0x01 16297 #define LOCATE_NOERR 0x02 16298 SQLITE_PRIVATE Table *sqlite3LocateTable(Parse*,u32 flags,
const char*,
const char*);
16299 SQLITE_PRIVATE Table *sqlite3LocateTableItem(Parse*,u32 flags,
struct SrcList_item *);
16300 SQLITE_PRIVATE Index *sqlite3FindIndex(
sqlite3*,
const char*,
const char*);
16301 SQLITE_PRIVATE
void sqlite3UnlinkAndDeleteTable(
sqlite3*,
int,
const char*);
16302 SQLITE_PRIVATE
void sqlite3UnlinkAndDeleteIndex(
sqlite3*,
int,
const char*);
16303 SQLITE_PRIVATE
void sqlite3Vacuum(Parse*);
16304 SQLITE_PRIVATE
int sqlite3RunVacuum(
char**,
sqlite3*);
16305 SQLITE_PRIVATE
char *sqlite3NameFromToken(
sqlite3*, Token*);
16306 SQLITE_PRIVATE
int sqlite3ExprCompare(Expr*, Expr*,
int);
16307 SQLITE_PRIVATE
int sqlite3ExprListCompare(ExprList*, ExprList*,
int);
16308 SQLITE_PRIVATE
int sqlite3ExprImpliesExpr(Expr*, Expr*,
int);
16309 SQLITE_PRIVATE
void sqlite3ExprAnalyzeAggregates(NameContext*, Expr*);
16310 SQLITE_PRIVATE
void sqlite3ExprAnalyzeAggList(NameContext*,ExprList*);
16311 SQLITE_PRIVATE
int sqlite3ExprCoveredByIndex(Expr*,
int iCur, Index *pIdx);
16312 SQLITE_PRIVATE
int sqlite3FunctionUsesThisSrc(Expr*, SrcList*);
16313 SQLITE_PRIVATE Vdbe *sqlite3GetVdbe(Parse*);
16314 #ifndef SQLITE_OMIT_BUILTIN_TEST 16315 SQLITE_PRIVATE
void sqlite3PrngSaveState(
void);
16316 SQLITE_PRIVATE
void sqlite3PrngRestoreState(
void);
16318 SQLITE_PRIVATE
void sqlite3RollbackAll(
sqlite3*,
int);
16319 SQLITE_PRIVATE
void sqlite3CodeVerifySchema(Parse*,
int);
16320 SQLITE_PRIVATE
void sqlite3CodeVerifyNamedSchema(Parse*,
const char *zDb);
16321 SQLITE_PRIVATE
void sqlite3BeginTransaction(Parse*,
int);
16322 SQLITE_PRIVATE
void sqlite3CommitTransaction(Parse*);
16323 SQLITE_PRIVATE
void sqlite3RollbackTransaction(Parse*);
16324 SQLITE_PRIVATE
void sqlite3Savepoint(Parse*,
int, Token*);
16325 SQLITE_PRIVATE
void sqlite3CloseSavepoints(
sqlite3 *);
16326 SQLITE_PRIVATE
void sqlite3LeaveMutexAndCloseZombie(
sqlite3*);
16327 SQLITE_PRIVATE
int sqlite3ExprIsConstant(Expr*);
16328 SQLITE_PRIVATE
int sqlite3ExprIsConstantNotJoin(Expr*);
16329 SQLITE_PRIVATE
int sqlite3ExprIsConstantOrFunction(Expr*, u8);
16330 SQLITE_PRIVATE
int sqlite3ExprIsTableConstant(Expr*,
int);
16331 #ifdef SQLITE_ENABLE_CURSOR_HINTS 16332 SQLITE_PRIVATE
int sqlite3ExprContainsSubquery(Expr*);
16334 SQLITE_PRIVATE
int sqlite3ExprIsInteger(Expr*,
int*);
16335 SQLITE_PRIVATE
int sqlite3ExprCanBeNull(
const Expr*);
16336 SQLITE_PRIVATE
int sqlite3ExprNeedsNoAffinityChange(
const Expr*,
char);
16337 SQLITE_PRIVATE
int sqlite3IsRowid(
const char*);
16338 SQLITE_PRIVATE
void sqlite3GenerateRowDelete(
16339 Parse*,Table*,Trigger*,
int,
int,
int,i16,u8,u8,u8,
int);
16340 SQLITE_PRIVATE
void sqlite3GenerateRowIndexDelete(Parse*, Table*,
int,
int,
int*,
int);
16341 SQLITE_PRIVATE
int sqlite3GenerateIndexKey(Parse*, Index*,
int,
int,
int,
int*,Index*,
int);
16342 SQLITE_PRIVATE
void sqlite3ResolvePartIdxLabel(Parse*,
int);
16343 SQLITE_PRIVATE
void sqlite3GenerateConstraintChecks(Parse*,Table*,
int*,
int,
int,
int,
int,
16344 u8,u8,
int,
int*,
int*);
16345 SQLITE_PRIVATE
void sqlite3CompleteInsertion(Parse*,Table*,
int,
int,
int,
int*,
int,
int,
int);
16346 SQLITE_PRIVATE
int sqlite3OpenTableAndIndices(Parse*, Table*,
int, u8,
int, u8*,
int*,
int*);
16347 SQLITE_PRIVATE
void sqlite3BeginWriteOperation(Parse*,
int,
int);
16348 SQLITE_PRIVATE
void sqlite3MultiWrite(Parse*);
16349 SQLITE_PRIVATE
void sqlite3MayAbort(Parse*);
16350 SQLITE_PRIVATE
void sqlite3HaltConstraint(Parse*,
int,
int,
char*, i8, u8);
16351 SQLITE_PRIVATE
void sqlite3UniqueConstraint(Parse*,
int, Index*);
16352 SQLITE_PRIVATE
void sqlite3RowidConstraint(Parse*,
int, Table*);
16353 SQLITE_PRIVATE Expr *sqlite3ExprDup(
sqlite3*,Expr*,
int);
16354 SQLITE_PRIVATE ExprList *sqlite3ExprListDup(
sqlite3*,ExprList*,
int);
16355 SQLITE_PRIVATE SrcList *sqlite3SrcListDup(
sqlite3*,SrcList*,
int);
16356 SQLITE_PRIVATE IdList *sqlite3IdListDup(
sqlite3*,IdList*);
16357 SQLITE_PRIVATE Select *sqlite3SelectDup(
sqlite3*,Select*,
int);
16358 #if SELECTTRACE_ENABLED 16359 SQLITE_PRIVATE
void sqlite3SelectSetName(Select*,
const char*);
16361 # define sqlite3SelectSetName(A,B) 16363 SQLITE_PRIVATE
void sqlite3InsertBuiltinFuncs(FuncDef*,
int);
16364 SQLITE_PRIVATE FuncDef *sqlite3FindFunction(
sqlite3*,
const char*,
int,u8,u8);
16365 SQLITE_PRIVATE
void sqlite3RegisterBuiltinFunctions(
void);
16366 SQLITE_PRIVATE
void sqlite3RegisterDateTimeFunctions(
void);
16367 SQLITE_PRIVATE
void sqlite3RegisterPerConnectionBuiltinFunctions(
sqlite3*);
16368 SQLITE_PRIVATE
int sqlite3SafetyCheckOk(
sqlite3*);
16369 SQLITE_PRIVATE
int sqlite3SafetyCheckSickOrOk(
sqlite3*);
16370 SQLITE_PRIVATE
void sqlite3ChangeCookie(Parse*,
int);
16372 #if !defined(SQLITE_OMIT_VIEW) && !defined(SQLITE_OMIT_TRIGGER) 16373 SQLITE_PRIVATE
void sqlite3MaterializeView(Parse*, Table*, Expr*,
int);
16376 #ifndef SQLITE_OMIT_TRIGGER 16377 SQLITE_PRIVATE
void sqlite3BeginTrigger(Parse*, Token*,Token*,
int,
int,IdList*,SrcList*,
16379 SQLITE_PRIVATE
void sqlite3FinishTrigger(Parse*, TriggerStep*, Token*);
16380 SQLITE_PRIVATE
void sqlite3DropTrigger(Parse*, SrcList*,
int);
16381 SQLITE_PRIVATE
void sqlite3DropTriggerPtr(Parse*, Trigger*);
16382 SQLITE_PRIVATE Trigger *sqlite3TriggersExist(Parse *, Table*,
int, ExprList*,
int *pMask);
16383 SQLITE_PRIVATE Trigger *sqlite3TriggerList(Parse *, Table *);
16384 SQLITE_PRIVATE
void sqlite3CodeRowTrigger(Parse*, Trigger *,
int, ExprList*,
int, Table *,
16386 SQLITE_PRIVATE
void sqlite3CodeRowTriggerDirect(Parse *, Trigger *, Table *,
int,
int,
int);
16387 void sqliteViewTriggers(Parse*, Table*, Expr*,
int, ExprList*);
16388 SQLITE_PRIVATE
void sqlite3DeleteTriggerStep(
sqlite3*, TriggerStep*);
16389 SQLITE_PRIVATE TriggerStep *sqlite3TriggerSelectStep(
sqlite3*,Select*);
16390 SQLITE_PRIVATE TriggerStep *sqlite3TriggerInsertStep(
sqlite3*,Token*, IdList*,
16392 SQLITE_PRIVATE TriggerStep *sqlite3TriggerUpdateStep(
sqlite3*,Token*,ExprList*, Expr*, u8);
16393 SQLITE_PRIVATE TriggerStep *sqlite3TriggerDeleteStep(
sqlite3*,Token*, Expr*);
16394 SQLITE_PRIVATE
void sqlite3DeleteTrigger(
sqlite3*, Trigger*);
16395 SQLITE_PRIVATE
void sqlite3UnlinkAndDeleteTrigger(
sqlite3*,
int,
const char*);
16396 SQLITE_PRIVATE u32 sqlite3TriggerColmask(Parse*,Trigger*,ExprList*,
int,
int,Table*,
int);
16397 # define sqlite3ParseToplevel(p) ((p)->pToplevel ? (p)->pToplevel : (p)) 16398 # define sqlite3IsToplevel(p) ((p)->pToplevel==0) 16400 # define sqlite3TriggersExist(B,C,D,E,F) 0 16401 # define sqlite3DeleteTrigger(A,B) 16402 # define sqlite3DropTriggerPtr(A,B) 16403 # define sqlite3UnlinkAndDeleteTrigger(A,B,C) 16404 # define sqlite3CodeRowTrigger(A,B,C,D,E,F,G,H,I) 16405 # define sqlite3CodeRowTriggerDirect(A,B,C,D,E,F) 16406 # define sqlite3TriggerList(X, Y) 0 16407 # define sqlite3ParseToplevel(p) p 16408 # define sqlite3IsToplevel(p) 1 16409 # define sqlite3TriggerColmask(A,B,C,D,E,F,G) 0 16412 SQLITE_PRIVATE
int sqlite3JoinType(Parse*, Token*, Token*, Token*);
16413 SQLITE_PRIVATE
void sqlite3CreateForeignKey(Parse*, ExprList*, Token*, ExprList*,
int);
16414 SQLITE_PRIVATE
void sqlite3DeferForeignKey(Parse*,
int);
16415 #ifndef SQLITE_OMIT_AUTHORIZATION 16416 SQLITE_PRIVATE
void sqlite3AuthRead(Parse*,Expr*,Schema*,SrcList*);
16417 SQLITE_PRIVATE
int sqlite3AuthCheck(Parse*,
int,
const char*,
const char*,
const char*);
16418 SQLITE_PRIVATE
void sqlite3AuthContextPush(Parse*, AuthContext*,
const char*);
16419 SQLITE_PRIVATE
void sqlite3AuthContextPop(AuthContext*);
16420 SQLITE_PRIVATE
int sqlite3AuthReadCol(Parse*,
const char *,
const char *,
int);
16422 # define sqlite3AuthRead(a,b,c,d) 16423 # define sqlite3AuthCheck(a,b,c,d,e) SQLITE_OK 16424 # define sqlite3AuthContextPush(a,b,c) 16425 # define sqlite3AuthContextPop(a) ((void)(a)) 16427 SQLITE_PRIVATE
void sqlite3Attach(Parse*, Expr*, Expr*, Expr*);
16428 SQLITE_PRIVATE
void sqlite3Detach(Parse*, Expr*);
16429 SQLITE_PRIVATE
void sqlite3FixInit(DbFixer*, Parse*,
int,
const char*,
const Token*);
16430 SQLITE_PRIVATE
int sqlite3FixSrcList(DbFixer*, SrcList*);
16431 SQLITE_PRIVATE
int sqlite3FixSelect(DbFixer*, Select*);
16432 SQLITE_PRIVATE
int sqlite3FixExpr(DbFixer*, Expr*);
16433 SQLITE_PRIVATE
int sqlite3FixExprList(DbFixer*, ExprList*);
16434 SQLITE_PRIVATE
int sqlite3FixTriggerStep(DbFixer*, TriggerStep*);
16435 SQLITE_PRIVATE
int sqlite3AtoF(
const char *z,
double*,
int, u8);
16436 SQLITE_PRIVATE
int sqlite3GetInt32(
const char *,
int*);
16437 SQLITE_PRIVATE
int sqlite3Atoi(
const char*);
16438 SQLITE_PRIVATE
int sqlite3Utf16ByteLen(
const void *pData,
int nChar);
16439 SQLITE_PRIVATE
int sqlite3Utf8CharLen(
const char *pData,
int nByte);
16440 SQLITE_PRIVATE u32 sqlite3Utf8Read(
const u8**);
16441 SQLITE_PRIVATE LogEst sqlite3LogEst(u64);
16442 SQLITE_PRIVATE LogEst sqlite3LogEstAdd(LogEst,LogEst);
16443 #ifndef SQLITE_OMIT_VIRTUALTABLE 16444 SQLITE_PRIVATE LogEst sqlite3LogEstFromDouble(
double);
16446 #if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || \ 16447 defined(SQLITE_ENABLE_STAT3_OR_STAT4) || \ 16448 defined(SQLITE_EXPLAIN_ESTIMATED_ROWS) 16449 SQLITE_PRIVATE u64 sqlite3LogEstToInt(LogEst);
16457 SQLITE_PRIVATE
int sqlite3PutVarint(
unsigned char*, u64);
16458 SQLITE_PRIVATE u8 sqlite3GetVarint(
const unsigned char *, u64 *);
16459 SQLITE_PRIVATE u8 sqlite3GetVarint32(
const unsigned char *, u32 *);
16460 SQLITE_PRIVATE
int sqlite3VarintLen(u64 v);
16467 #define getVarint32(A,B) \ 16468 (u8)((*(A)<(u8)0x80)?((B)=(u32)*(A)),1:sqlite3GetVarint32((A),(u32 *)&(B))) 16469 #define putVarint32(A,B) \ 16470 (u8)(((u32)(B)<(u32)0x80)?(*(A)=(unsigned char)(B)),1:\ 16471 sqlite3PutVarint((A),(B))) 16472 #define getVarint sqlite3GetVarint 16473 #define putVarint sqlite3PutVarint 16476 SQLITE_PRIVATE
const char *sqlite3IndexAffinityStr(
sqlite3*, Index*);
16477 SQLITE_PRIVATE
void sqlite3TableAffinity(Vdbe*, Table*,
int);
16478 SQLITE_PRIVATE
char sqlite3CompareAffinity(Expr *pExpr,
char aff2);
16479 SQLITE_PRIVATE
int sqlite3IndexAffinityOk(Expr *pExpr,
char idx_affinity);
16480 SQLITE_PRIVATE
char sqlite3ExprAffinity(Expr *pExpr);
16481 SQLITE_PRIVATE
int sqlite3Atoi64(
const char*, i64*,
int, u8);
16482 SQLITE_PRIVATE
int sqlite3DecOrHexToI64(
const char*, i64*);
16483 SQLITE_PRIVATE
void sqlite3ErrorWithMsg(
sqlite3*,
int,
const char*,...);
16484 SQLITE_PRIVATE
void sqlite3Error(
sqlite3*,
int);
16485 SQLITE_PRIVATE
void sqlite3SystemError(
sqlite3*,
int);
16486 SQLITE_PRIVATE
void *sqlite3HexToBlob(
sqlite3*,
const char *z,
int n);
16487 SQLITE_PRIVATE u8 sqlite3HexToInt(
int h);
16488 SQLITE_PRIVATE
int sqlite3TwoPartName(Parse *, Token *, Token *, Token **);
16490 #if defined(SQLITE_NEED_ERR_NAME) 16491 SQLITE_PRIVATE
const char *sqlite3ErrName(
int);
16494 SQLITE_PRIVATE
const char *sqlite3ErrStr(
int);
16495 SQLITE_PRIVATE
int sqlite3ReadSchema(Parse *pParse);
16496 SQLITE_PRIVATE CollSeq *sqlite3FindCollSeq(
sqlite3*,u8 enc,
const char*,
int);
16497 SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse,
const char*zName);
16498 SQLITE_PRIVATE CollSeq *sqlite3ExprCollSeq(Parse *pParse, Expr *pExpr);
16499 SQLITE_PRIVATE Expr *sqlite3ExprAddCollateToken(Parse *pParse, Expr*,
const Token*,
int);
16500 SQLITE_PRIVATE Expr *sqlite3ExprAddCollateString(Parse*,Expr*,
const char*);
16501 SQLITE_PRIVATE Expr *sqlite3ExprSkipCollate(Expr*);
16502 SQLITE_PRIVATE
int sqlite3CheckCollSeq(Parse *, CollSeq *);
16503 SQLITE_PRIVATE
int sqlite3CheckObjectName(Parse *,
const char *);
16504 SQLITE_PRIVATE
void sqlite3VdbeSetChanges(
sqlite3 *,
int);
16505 SQLITE_PRIVATE
int sqlite3AddInt64(i64*,i64);
16506 SQLITE_PRIVATE
int sqlite3SubInt64(i64*,i64);
16507 SQLITE_PRIVATE
int sqlite3MulInt64(i64*,i64);
16508 SQLITE_PRIVATE
int sqlite3AbsInt32(
int);
16509 #ifdef SQLITE_ENABLE_8_3_NAMES 16510 SQLITE_PRIVATE
void sqlite3FileSuffix3(
const char*,
char*);
16512 # define sqlite3FileSuffix3(X,Y) 16514 SQLITE_PRIVATE u8 sqlite3GetBoolean(
const char *z,u8);
16516 SQLITE_PRIVATE
const void *sqlite3ValueText(
sqlite3_value*, u8);
16518 SQLITE_PRIVATE
void sqlite3ValueSetStr(
sqlite3_value*,
int,
const void *,u8,
16523 SQLITE_PRIVATE
char *sqlite3Utf16to8(
sqlite3 *,
const void*,
int, u8);
16525 SQLITE_PRIVATE
void sqlite3ValueApplyAffinity(
sqlite3_value *, u8, u8);
16526 #ifndef SQLITE_AMALGAMATION 16527 SQLITE_PRIVATE
const unsigned char sqlite3OpcodeProperty[];
16528 SQLITE_PRIVATE
const char sqlite3StrBINARY[];
16529 SQLITE_PRIVATE
const unsigned char sqlite3UpperToLower[];
16530 SQLITE_PRIVATE
const unsigned char sqlite3CtypeMap[];
16531 SQLITE_PRIVATE
const Token sqlite3IntTokens[];
16532 SQLITE_PRIVATE SQLITE_WSD
struct Sqlite3Config sqlite3Config;
16533 SQLITE_PRIVATE FuncDefHash sqlite3BuiltinFunctions;
16534 #ifndef SQLITE_OMIT_WSD 16535 SQLITE_PRIVATE
int sqlite3PendingByte;
16538 SQLITE_PRIVATE
void sqlite3RootPageMoved(
sqlite3*,
int,
int,
int);
16539 SQLITE_PRIVATE
void sqlite3Reindex(Parse*, Token*, Token*);
16540 SQLITE_PRIVATE
void sqlite3AlterFunctions(
void);
16541 SQLITE_PRIVATE
void sqlite3AlterRenameTable(Parse*, SrcList*, Token*);
16542 SQLITE_PRIVATE
int sqlite3GetToken(
const unsigned char *,
int *);
16543 SQLITE_PRIVATE
void sqlite3NestedParse(Parse*,
const char*, ...);
16544 SQLITE_PRIVATE
void sqlite3ExpirePreparedStatements(
sqlite3*);
16545 SQLITE_PRIVATE
int sqlite3CodeSubselect(Parse *, Expr *,
int,
int);
16546 SQLITE_PRIVATE
void sqlite3SelectPrep(Parse*, Select*, NameContext*);
16547 SQLITE_PRIVATE
void sqlite3SelectWrongNumTermsError(Parse *pParse, Select *p);
16548 SQLITE_PRIVATE
int sqlite3MatchSpanName(
const char*,
const char*,
const char*,
const char*);
16549 SQLITE_PRIVATE
int sqlite3ResolveExprNames(NameContext*, Expr*);
16550 SQLITE_PRIVATE
int sqlite3ResolveExprListNames(NameContext*, ExprList*);
16551 SQLITE_PRIVATE
void sqlite3ResolveSelectNames(Parse*, Select*, NameContext*);
16552 SQLITE_PRIVATE
void sqlite3ResolveSelfReference(Parse*,Table*,
int,Expr*,ExprList*);
16553 SQLITE_PRIVATE
int sqlite3ResolveOrderGroupBy(Parse*, Select*, ExprList*,
const char*);
16554 SQLITE_PRIVATE
void sqlite3ColumnDefault(Vdbe *, Table *,
int,
int);
16555 SQLITE_PRIVATE
void sqlite3AlterFinishAddColumn(Parse *, Token *);
16556 SQLITE_PRIVATE
void sqlite3AlterBeginAddColumn(Parse *, SrcList *);
16557 SQLITE_PRIVATE CollSeq *sqlite3GetCollSeq(Parse*, u8, CollSeq *,
const char*);
16558 SQLITE_PRIVATE
char sqlite3AffinityType(
const char*, u8*);
16559 SQLITE_PRIVATE
void sqlite3Analyze(Parse*, Token*, Token*);
16560 SQLITE_PRIVATE
int sqlite3InvokeBusyHandler(BusyHandler*);
16561 SQLITE_PRIVATE
int sqlite3FindDb(
sqlite3*, Token*);
16562 SQLITE_PRIVATE
int sqlite3FindDbName(
sqlite3 *,
const char *);
16563 SQLITE_PRIVATE
int sqlite3AnalysisLoad(
sqlite3*,
int iDB);
16564 SQLITE_PRIVATE
void sqlite3DeleteIndexSamples(
sqlite3*,Index*);
16565 SQLITE_PRIVATE
void sqlite3DefaultRowEst(Index*);
16566 SQLITE_PRIVATE
void sqlite3RegisterLikeFunctions(
sqlite3*,
int);
16567 SQLITE_PRIVATE
int sqlite3IsLikeFunction(
sqlite3*,Expr*,
int*,
char*);
16568 SQLITE_PRIVATE
void sqlite3SchemaClear(
void *);
16569 SQLITE_PRIVATE Schema *sqlite3SchemaGet(
sqlite3 *, Btree *);
16570 SQLITE_PRIVATE
int sqlite3SchemaToIndex(
sqlite3 *db, Schema *);
16571 SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoAlloc(
sqlite3*,
int,
int);
16572 SQLITE_PRIVATE
void sqlite3KeyInfoUnref(KeyInfo*);
16573 SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoRef(KeyInfo*);
16574 SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoOfIndex(Parse*, Index*);
16575 #ifdef SQLITE_DEBUG 16576 SQLITE_PRIVATE
int sqlite3KeyInfoIsWriteable(KeyInfo*);
16578 SQLITE_PRIVATE
int sqlite3CreateFunc(
sqlite3 *,
const char *,
int,
int,
void *,
16581 FuncDestructor *pDestructor
16583 SQLITE_PRIVATE
void sqlite3OomFault(
sqlite3*);
16584 SQLITE_PRIVATE
void sqlite3OomClear(
sqlite3*);
16585 SQLITE_PRIVATE
int sqlite3ApiExit(
sqlite3 *db,
int);
16586 SQLITE_PRIVATE
int sqlite3OpenTempDatabase(Parse *);
16588 SQLITE_PRIVATE
void sqlite3StrAccumInit(StrAccum*,
sqlite3*,
char*,
int,
int);
16589 SQLITE_PRIVATE
void sqlite3StrAccumAppend(StrAccum*,
const char*,
int);
16590 SQLITE_PRIVATE
void sqlite3StrAccumAppendAll(StrAccum*,
const char*);
16591 SQLITE_PRIVATE
void sqlite3AppendChar(StrAccum*,
int,
char);
16592 SQLITE_PRIVATE
char *sqlite3StrAccumFinish(StrAccum*);
16593 SQLITE_PRIVATE
void sqlite3StrAccumReset(StrAccum*);
16594 SQLITE_PRIVATE
void sqlite3SelectDestInit(SelectDest*,
int,
int);
16595 SQLITE_PRIVATE Expr *sqlite3CreateColumnExpr(
sqlite3 *, SrcList *,
int,
int);
16598 SQLITE_PRIVATE
void sqlite3BackupUpdate(
sqlite3_backup *, Pgno,
const u8 *);
16600 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4 16601 SQLITE_PRIVATE
void sqlite3AnalyzeFunctions(
void);
16602 SQLITE_PRIVATE
int sqlite3Stat4ProbeSetValue(Parse*,Index*,UnpackedRecord**,Expr*,u8,
int,
int*);
16603 SQLITE_PRIVATE
int sqlite3Stat4ValueFromExpr(Parse*, Expr*, u8,
sqlite3_value**);
16604 SQLITE_PRIVATE
void sqlite3Stat4ProbeFree(UnpackedRecord*);
16611 SQLITE_PRIVATE
void *sqlite3ParserAlloc(
void*(*)(u64));
16612 SQLITE_PRIVATE
void sqlite3ParserFree(
void*,
void(*)(
void*));
16613 SQLITE_PRIVATE
void sqlite3Parser(
void*,
int, Token, Parse*);
16614 #ifdef YYTRACKMAXSTACKDEPTH 16615 SQLITE_PRIVATE
int sqlite3ParserStackPeak(
void*);
16618 SQLITE_PRIVATE
void sqlite3AutoLoadExtensions(
sqlite3*);
16619 #ifndef SQLITE_OMIT_LOAD_EXTENSION 16620 SQLITE_PRIVATE
void sqlite3CloseExtensions(
sqlite3*);
16622 # define sqlite3CloseExtensions(X) 16625 #ifndef SQLITE_OMIT_SHARED_CACHE 16626 SQLITE_PRIVATE
void sqlite3TableLock(Parse *,
int,
int, u8,
const char *);
16628 #define sqlite3TableLock(v,w,x,y,z) 16632 SQLITE_PRIVATE
int sqlite3Utf8To8(
unsigned char*);
16635 #ifdef SQLITE_OMIT_VIRTUALTABLE 16636 # define sqlite3VtabClear(Y) 16637 # define sqlite3VtabSync(X,Y) SQLITE_OK 16638 # define sqlite3VtabRollback(X) 16639 # define sqlite3VtabCommit(X) 16640 # define sqlite3VtabInSync(db) 0 16641 # define sqlite3VtabLock(X) 16642 # define sqlite3VtabUnlock(X) 16643 # define sqlite3VtabUnlockList(X) 16644 # define sqlite3VtabSavepoint(X, Y, Z) SQLITE_OK 16645 # define sqlite3GetVTable(X,Y) ((VTable*)0) 16647 SQLITE_PRIVATE
void sqlite3VtabClear(
sqlite3 *db, Table*);
16648 SQLITE_PRIVATE
void sqlite3VtabDisconnect(
sqlite3 *db, Table *p);
16649 SQLITE_PRIVATE
int sqlite3VtabSync(
sqlite3 *db, Vdbe*);
16650 SQLITE_PRIVATE
int sqlite3VtabRollback(
sqlite3 *db);
16651 SQLITE_PRIVATE
int sqlite3VtabCommit(
sqlite3 *db);
16652 SQLITE_PRIVATE
void sqlite3VtabLock(VTable *);
16653 SQLITE_PRIVATE
void sqlite3VtabUnlock(VTable *);
16654 SQLITE_PRIVATE
void sqlite3VtabUnlockList(
sqlite3*);
16655 SQLITE_PRIVATE
int sqlite3VtabSavepoint(
sqlite3 *,
int,
int);
16656 SQLITE_PRIVATE
void sqlite3VtabImportErrmsg(Vdbe*,
sqlite3_vtab*);
16657 SQLITE_PRIVATE VTable *sqlite3GetVTable(
sqlite3*, Table*);
16658 # define sqlite3VtabInSync(db) ((db)->nVTrans>0 && (db)->aVTrans==0) 16660 SQLITE_PRIVATE
int sqlite3VtabEponymousTableInit(Parse*,Module*);
16661 SQLITE_PRIVATE
void sqlite3VtabEponymousTableClear(
sqlite3*,Module*);
16662 SQLITE_PRIVATE
void sqlite3VtabMakeWritable(Parse*,Table*);
16663 SQLITE_PRIVATE
void sqlite3VtabBeginParse(Parse*, Token*, Token*, Token*,
int);
16664 SQLITE_PRIVATE
void sqlite3VtabFinishParse(Parse*, Token*);
16665 SQLITE_PRIVATE
void sqlite3VtabArgInit(Parse*);
16666 SQLITE_PRIVATE
void sqlite3VtabArgExtend(Parse*, Token*);
16667 SQLITE_PRIVATE
int sqlite3VtabCallCreate(
sqlite3*,
int,
const char *,
char **);
16668 SQLITE_PRIVATE
int sqlite3VtabCallConnect(Parse*, Table*);
16669 SQLITE_PRIVATE
int sqlite3VtabCallDestroy(
sqlite3*,
int,
const char *);
16670 SQLITE_PRIVATE
int sqlite3VtabBegin(
sqlite3 *, VTable *);
16671 SQLITE_PRIVATE FuncDef *sqlite3VtabOverloadFunction(
sqlite3 *,FuncDef*,
int nArg, Expr*);
16673 SQLITE_PRIVATE sqlite3_int64 sqlite3StmtCurrentTime(
sqlite3_context*);
16674 SQLITE_PRIVATE
int sqlite3VdbeParameterIndex(Vdbe*,
const char*,
int);
16675 SQLITE_PRIVATE
int sqlite3TransferBindings(sqlite3_stmt *, sqlite3_stmt *);
16676 SQLITE_PRIVATE
void sqlite3ParserReset(Parse*);
16677 SQLITE_PRIVATE
int sqlite3Reprepare(Vdbe*);
16678 SQLITE_PRIVATE
void sqlite3ExprListCheckLength(Parse*, ExprList*,
const char*);
16679 SQLITE_PRIVATE CollSeq *sqlite3BinaryCompareCollSeq(Parse *, Expr *, Expr *);
16680 SQLITE_PRIVATE
int sqlite3TempInMemory(
const sqlite3*);
16681 SQLITE_PRIVATE
const char *sqlite3JournalModename(
int);
16682 #ifndef SQLITE_OMIT_WAL 16683 SQLITE_PRIVATE
int sqlite3Checkpoint(
sqlite3*,
int,
int,
int*,
int*);
16684 SQLITE_PRIVATE
int sqlite3WalDefaultHook(
void*,
sqlite3*,
const char*,
int);
16686 #ifndef SQLITE_OMIT_CTE 16687 SQLITE_PRIVATE With *sqlite3WithAdd(Parse*,With*,Token*,ExprList*,Select*);
16688 SQLITE_PRIVATE
void sqlite3WithDelete(
sqlite3*,With*);
16689 SQLITE_PRIVATE
void sqlite3WithPush(Parse*, With*, u8);
16691 #define sqlite3WithPush(x,y,z) 16692 #define sqlite3WithDelete(x,y) 16702 #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER) 16703 SQLITE_PRIVATE
void sqlite3FkCheck(Parse*, Table*,
int,
int,
int*,
int);
16704 SQLITE_PRIVATE
void sqlite3FkDropTable(Parse*, SrcList *, Table*);
16705 SQLITE_PRIVATE
void sqlite3FkActions(Parse*, Table*, ExprList*,
int,
int*,
int);
16706 SQLITE_PRIVATE
int sqlite3FkRequired(Parse*, Table*,
int*,
int);
16707 SQLITE_PRIVATE u32 sqlite3FkOldmask(Parse*, Table*);
16708 SQLITE_PRIVATE FKey *sqlite3FkReferences(Table *);
16710 #define sqlite3FkActions(a,b,c,d,e,f) 16711 #define sqlite3FkCheck(a,b,c,d,e,f) 16712 #define sqlite3FkDropTable(a,b,c) 16713 #define sqlite3FkOldmask(a,b) 0 16714 #define sqlite3FkRequired(a,b,c,d) 0 16716 #ifndef SQLITE_OMIT_FOREIGN_KEY 16717 SQLITE_PRIVATE
void sqlite3FkDelete(
sqlite3 *, Table*);
16718 SQLITE_PRIVATE
int sqlite3FkLocateIndex(Parse*,Table*,FKey*,Index**,
int**);
16720 #define sqlite3FkDelete(a,b) 16721 #define sqlite3FkLocateIndex(a,b,c,d,e) 16728 #define SQLITE_FAULTINJECTOR_MALLOC 0 16729 #define SQLITE_FAULTINJECTOR_COUNT 1 16736 #ifndef SQLITE_OMIT_BUILTIN_TEST 16737 SQLITE_PRIVATE
void sqlite3BeginBenignMalloc(
void);
16738 SQLITE_PRIVATE
void sqlite3EndBenignMalloc(
void);
16740 #define sqlite3BeginBenignMalloc() 16741 #define sqlite3EndBenignMalloc() 16747 #define IN_INDEX_ROWID 1 16748 #define IN_INDEX_EPH 2 16749 #define IN_INDEX_INDEX_ASC 3 16750 #define IN_INDEX_INDEX_DESC 4 16751 #define IN_INDEX_NOOP 5 16755 #define IN_INDEX_NOOP_OK 0x0001 16756 #define IN_INDEX_MEMBERSHIP 0x0002 16757 #define IN_INDEX_LOOP 0x0004 16758 SQLITE_PRIVATE
int sqlite3FindInIndex(Parse *, Expr *, u32,
int*);
16761 SQLITE_PRIVATE
int sqlite3JournalSize(
sqlite3_vfs *);
16762 #ifdef SQLITE_ENABLE_ATOMIC_WRITE 16763 SQLITE_PRIVATE
int sqlite3JournalCreate(
sqlite3_file *);
16766 SQLITE_PRIVATE
int sqlite3JournalIsInMemory(
sqlite3_file *p);
16767 SQLITE_PRIVATE
void sqlite3MemJournalOpen(
sqlite3_file *);
16769 SQLITE_PRIVATE
void sqlite3ExprSetHeightAndFlags(Parse *pParse, Expr *p);
16770 #if SQLITE_MAX_EXPR_DEPTH>0 16771 SQLITE_PRIVATE
int sqlite3SelectExprHeight(Select *);
16772 SQLITE_PRIVATE
int sqlite3ExprCheckHeight(Parse*,
int);
16774 #define sqlite3SelectExprHeight(x) 0 16775 #define sqlite3ExprCheckHeight(x,y) 16778 SQLITE_PRIVATE u32 sqlite3Get4byte(
const u8*);
16779 SQLITE_PRIVATE
void sqlite3Put4byte(u8*, u32);
16781 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY 16782 SQLITE_PRIVATE
void sqlite3ConnectionBlocked(
sqlite3 *,
sqlite3 *);
16783 SQLITE_PRIVATE
void sqlite3ConnectionUnlocked(
sqlite3 *db);
16784 SQLITE_PRIVATE
void sqlite3ConnectionClosed(
sqlite3 *db);
16786 #define sqlite3ConnectionBlocked(x,y) 16787 #define sqlite3ConnectionUnlocked(x) 16788 #define sqlite3ConnectionClosed(x) 16791 #ifdef SQLITE_DEBUG 16792 SQLITE_PRIVATE
void sqlite3ParserTrace(FILE*,
char *);
16800 #ifdef SQLITE_ENABLE_IOTRACE 16801 # define IOTRACE(A) if( sqlite3IoTrace ){ sqlite3IoTrace A; } 16802 SQLITE_PRIVATE
void sqlite3VdbeIOTraceSql(Vdbe*);
16803 SQLITE_API SQLITE_EXTERN void (SQLITE_CDECL *sqlite3IoTrace)(
const char*,...);
16805 # define IOTRACE(A) 16806 # define sqlite3VdbeIOTraceSql(X) 16837 #ifdef SQLITE_MEMDEBUG 16838 SQLITE_PRIVATE
void sqlite3MemdebugSetType(
void*,u8);
16839 SQLITE_PRIVATE
int sqlite3MemdebugHasType(
void*,u8);
16840 SQLITE_PRIVATE
int sqlite3MemdebugNoType(
void*,u8);
16842 # define sqlite3MemdebugSetType(X,Y) 16843 # define sqlite3MemdebugHasType(X,Y) 1 16844 # define sqlite3MemdebugNoType(X,Y) 1 16846 #define MEMTYPE_HEAP 0x01 16847 #define MEMTYPE_LOOKASIDE 0x02 16848 #define MEMTYPE_SCRATCH 0x04 16849 #define MEMTYPE_PCACHE 0x08 16854 #if SQLITE_MAX_WORKER_THREADS>0 16855 SQLITE_PRIVATE
int sqlite3ThreadCreate(SQLiteThread**,
void*(*)(
void*),
void*);
16856 SQLITE_PRIVATE
int sqlite3ThreadJoin(SQLiteThread*,
void**);
16859 #if defined(SQLITE_ENABLE_DBSTAT_VTAB) || defined(SQLITE_TEST) 16860 SQLITE_PRIVATE
int sqlite3DbstatRegister(
sqlite3*);
16890 SQLITE_PRIVATE
const unsigned char sqlite3UpperToLower[] = {
16891 #ifdef SQLITE_ASCII 16892 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
16893 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
16894 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
16895 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 97, 98, 99,100,101,102,103,
16896 104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,
16897 122, 91, 92, 93, 94, 95, 96, 97, 98, 99,100,101,102,103,104,105,106,107,
16898 108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,
16899 126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
16900 144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,
16901 162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,
16902 180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,
16903 198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,
16904 216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,
16905 234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,
16908 #ifdef SQLITE_EBCDIC 16909 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16910 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
16911 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
16912 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
16913 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
16914 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
16915 96, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111,
16916 112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,
16917 128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
16918 144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,
16919 160,161,162,163,164,165,166,167,168,169,170,171,140,141,142,175,
16920 176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,
16921 192,129,130,131,132,133,134,135,136,137,202,203,204,205,206,207,
16922 208,145,146,147,148,149,150,151,152,153,218,219,220,221,222,223,
16923 224,225,162,163,164,165,166,167,168,169,234,235,236,237,238,239,
16924 240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,
16959 #ifdef SQLITE_ASCII 16960 SQLITE_PRIVATE
const unsigned char sqlite3CtypeMap[256] = {
16961 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
16962 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00,
16963 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
16964 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
16965 0x01, 0x00, 0x80, 0x00, 0x40, 0x00, 0x00, 0x80,
16966 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
16967 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
16968 0x0c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
16970 0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x02,
16971 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
16972 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
16973 0x02, 0x02, 0x02, 0x80, 0x00, 0x00, 0x00, 0x40,
16974 0x80, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x22,
16975 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
16976 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
16977 0x22, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00,
16979 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
16980 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
16981 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
16982 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
16983 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
16984 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
16985 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
16986 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
16988 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
16989 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
16990 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
16991 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
16992 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
16993 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
16994 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
16995 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40
17010 #ifndef SQLITE_USE_URI 17011 # define SQLITE_USE_URI 0 17018 #ifndef SQLITE_ALLOW_COVERING_INDEX_SCAN 17019 # define SQLITE_ALLOW_COVERING_INDEX_SCAN 1 17025 #ifndef SQLITE_SORTER_PMASZ 17026 # define SQLITE_SORTER_PMASZ 250 17037 #ifndef SQLITE_STMTJRNL_SPILL 17038 # define SQLITE_STMTJRNL_SPILL (64*1024) 17045 SQLITE_PRIVATE SQLITE_WSD
struct Sqlite3Config sqlite3Config = {
17046 SQLITE_DEFAULT_MEMSTATUS,
17048 SQLITE_THREADSAFE==1,
17050 SQLITE_ALLOW_COVERING_INDEX_SCAN,
17055 SQLITE_STMTJRNL_SPILL,
17057 {0,0,0,0,0,0,0,0,0},
17058 {0,0,0,0,0,0,0,0,0,0,0,0,0},
17062 SQLITE_DEFAULT_MMAP_SIZE,
17063 SQLITE_MAX_MMAP_SIZE,
17069 SQLITE_DEFAULT_PCACHE_INITSZ,
17072 SQLITE_SORTER_PMASZ,
17083 #ifdef SQLITE_ENABLE_SQLLOG
17087 #ifdef SQLITE_VDBE_COVERAGE
17091 #ifndef SQLITE_OMIT_BUILTIN_TEST
17102 SQLITE_PRIVATE FuncDefHash sqlite3BuiltinFunctions;
17107 SQLITE_PRIVATE
const Token sqlite3IntTokens[] = {
17131 #ifndef SQLITE_OMIT_WSD 17132 SQLITE_PRIVATE
int sqlite3PendingByte = 0x40000000;
17142 SQLITE_PRIVATE
const unsigned char sqlite3OpcodeProperty[] = OPFLG_INITIALIZER;
17147 SQLITE_PRIVATE
const char sqlite3StrBINARY[] =
"BINARY";
17167 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS 17179 static const char *
const azCompileOpt[] = {
17183 #define CTIMEOPT_VAL_(opt) #opt 17184 #define CTIMEOPT_VAL(opt) CTIMEOPT_VAL_(opt) 17186 #if SQLITE_32BIT_ROWID 17189 #if SQLITE_4_BYTE_ALIGNED_MALLOC 17190 "4_BYTE_ALIGNED_MALLOC",
17192 #if SQLITE_CASE_SENSITIVE_LIKE 17193 "CASE_SENSITIVE_LIKE",
17195 #if SQLITE_CHECK_PAGES 17198 #if defined(__clang__) && defined(__clang_major__) 17199 "COMPILER=clang-" CTIMEOPT_VAL(__clang_major__)
"." 17200 CTIMEOPT_VAL(__clang_minor__)
"." 17201 CTIMEOPT_VAL(__clang_patchlevel__),
17202 #elif defined(_MSC_VER) 17203 "COMPILER=msvc-" CTIMEOPT_VAL(_MSC_VER),
17204 #elif defined(__GNUC__) && defined(__VERSION__) 17205 "COMPILER=gcc-" __VERSION__,
17207 #if SQLITE_COVERAGE_TEST 17213 #if SQLITE_DEFAULT_LOCKING_MODE 17214 "DEFAULT_LOCKING_MODE=" CTIMEOPT_VAL(SQLITE_DEFAULT_LOCKING_MODE),
17216 #if defined(SQLITE_DEFAULT_MMAP_SIZE) && !defined(SQLITE_DEFAULT_MMAP_SIZE_xc) 17217 "DEFAULT_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_DEFAULT_MMAP_SIZE),
17219 #if SQLITE_DISABLE_DIRSYNC 17222 #if SQLITE_DISABLE_LFS 17225 #if SQLITE_ENABLE_8_3_NAMES 17226 "ENABLE_8_3_NAMES=" CTIMEOPT_VAL(SQLITE_ENABLE_8_3_NAMES),
17228 #if SQLITE_ENABLE_API_ARMOR 17229 "ENABLE_API_ARMOR",
17231 #if SQLITE_ENABLE_ATOMIC_WRITE 17232 "ENABLE_ATOMIC_WRITE",
17234 #if SQLITE_ENABLE_CEROD 17237 #if SQLITE_ENABLE_COLUMN_METADATA 17238 "ENABLE_COLUMN_METADATA",
17240 #if SQLITE_ENABLE_DBSTAT_VTAB 17241 "ENABLE_DBSTAT_VTAB",
17243 #if SQLITE_ENABLE_EXPENSIVE_ASSERT 17244 "ENABLE_EXPENSIVE_ASSERT",
17246 #if SQLITE_ENABLE_FTS1 17249 #if SQLITE_ENABLE_FTS2 17252 #if SQLITE_ENABLE_FTS3 17255 #if SQLITE_ENABLE_FTS3_PARENTHESIS 17256 "ENABLE_FTS3_PARENTHESIS",
17258 #if SQLITE_ENABLE_FTS4 17261 #if SQLITE_ENABLE_FTS5 17264 #if SQLITE_ENABLE_ICU 17267 #if SQLITE_ENABLE_IOTRACE 17270 #if SQLITE_ENABLE_JSON1 17273 #if SQLITE_ENABLE_LOAD_EXTENSION 17274 "ENABLE_LOAD_EXTENSION",
17276 #if SQLITE_ENABLE_LOCKING_STYLE 17277 "ENABLE_LOCKING_STYLE=" CTIMEOPT_VAL(SQLITE_ENABLE_LOCKING_STYLE),
17279 #if SQLITE_ENABLE_MEMORY_MANAGEMENT 17280 "ENABLE_MEMORY_MANAGEMENT",
17282 #if SQLITE_ENABLE_MEMSYS3 17285 #if SQLITE_ENABLE_MEMSYS5 17288 #if SQLITE_ENABLE_OVERSIZE_CELL_CHECK 17289 "ENABLE_OVERSIZE_CELL_CHECK",
17291 #if SQLITE_ENABLE_RTREE 17294 #if defined(SQLITE_ENABLE_STAT4) 17296 #elif defined(SQLITE_ENABLE_STAT3) 17299 #if SQLITE_ENABLE_UNLOCK_NOTIFY 17300 "ENABLE_UNLOCK_NOTIFY",
17302 #if SQLITE_ENABLE_UPDATE_DELETE_LIMIT 17303 "ENABLE_UPDATE_DELETE_LIMIT",
17305 #if SQLITE_HAS_CODEC 17308 #if HAVE_ISNAN || SQLITE_HAVE_ISNAN 17311 #if SQLITE_HOMEGROWN_RECURSIVE_MUTEX 17312 "HOMEGROWN_RECURSIVE_MUTEX",
17314 #if SQLITE_IGNORE_AFP_LOCK_ERRORS 17315 "IGNORE_AFP_LOCK_ERRORS",
17317 #if SQLITE_IGNORE_FLOCK_LOCK_ERRORS 17318 "IGNORE_FLOCK_LOCK_ERRORS",
17320 #ifdef SQLITE_INT64_TYPE 17323 #ifdef SQLITE_LIKE_DOESNT_MATCH_BLOBS 17324 "LIKE_DOESNT_MATCH_BLOBS",
17326 #if SQLITE_LOCK_TRACE 17329 #if defined(SQLITE_MAX_MMAP_SIZE) && !defined(SQLITE_MAX_MMAP_SIZE_xc) 17330 "MAX_MMAP_SIZE=" CTIMEOPT_VAL(SQLITE_MAX_MMAP_SIZE),
17332 #ifdef SQLITE_MAX_SCHEMA_RETRY 17333 "MAX_SCHEMA_RETRY=" CTIMEOPT_VAL(SQLITE_MAX_SCHEMA_RETRY),
17335 #if SQLITE_MEMDEBUG 17338 #if SQLITE_MIXED_ENDIAN_64BIT_FLOAT 17339 "MIXED_ENDIAN_64BIT_FLOAT",
17344 #if SQLITE_OMIT_ALTERTABLE 17347 #if SQLITE_OMIT_ANALYZE 17350 #if SQLITE_OMIT_ATTACH 17353 #if SQLITE_OMIT_AUTHORIZATION 17354 "OMIT_AUTHORIZATION",
17356 #if SQLITE_OMIT_AUTOINCREMENT 17357 "OMIT_AUTOINCREMENT",
17359 #if SQLITE_OMIT_AUTOINIT 17362 #if SQLITE_OMIT_AUTOMATIC_INDEX 17363 "OMIT_AUTOMATIC_INDEX",
17365 #if SQLITE_OMIT_AUTORESET 17368 #if SQLITE_OMIT_AUTOVACUUM 17371 #if SQLITE_OMIT_BETWEEN_OPTIMIZATION 17372 "OMIT_BETWEEN_OPTIMIZATION",
17374 #if SQLITE_OMIT_BLOB_LITERAL 17375 "OMIT_BLOB_LITERAL",
17377 #if SQLITE_OMIT_BTREECOUNT 17380 #if SQLITE_OMIT_BUILTIN_TEST 17381 "OMIT_BUILTIN_TEST",
17383 #if SQLITE_OMIT_CAST 17386 #if SQLITE_OMIT_CHECK 17389 #if SQLITE_OMIT_COMPLETE 17392 #if SQLITE_OMIT_COMPOUND_SELECT 17393 "OMIT_COMPOUND_SELECT",
17395 #if SQLITE_OMIT_CTE 17398 #if SQLITE_OMIT_DATETIME_FUNCS 17399 "OMIT_DATETIME_FUNCS",
17401 #if SQLITE_OMIT_DECLTYPE 17404 #if SQLITE_OMIT_DEPRECATED 17407 #if SQLITE_OMIT_DISKIO 17410 #if SQLITE_OMIT_EXPLAIN 17413 #if SQLITE_OMIT_FLAG_PRAGMAS 17414 "OMIT_FLAG_PRAGMAS",
17416 #if SQLITE_OMIT_FLOATING_POINT 17417 "OMIT_FLOATING_POINT",
17419 #if SQLITE_OMIT_FOREIGN_KEY 17420 "OMIT_FOREIGN_KEY",
17422 #if SQLITE_OMIT_GET_TABLE 17425 #if SQLITE_OMIT_INCRBLOB 17428 #if SQLITE_OMIT_INTEGRITY_CHECK 17429 "OMIT_INTEGRITY_CHECK",
17431 #if SQLITE_OMIT_LIKE_OPTIMIZATION 17432 "OMIT_LIKE_OPTIMIZATION",
17434 #if SQLITE_OMIT_LOAD_EXTENSION 17435 "OMIT_LOAD_EXTENSION",
17437 #if SQLITE_OMIT_LOCALTIME 17440 #if SQLITE_OMIT_LOOKASIDE 17443 #if SQLITE_OMIT_MEMORYDB 17446 #if SQLITE_OMIT_OR_OPTIMIZATION 17447 "OMIT_OR_OPTIMIZATION",
17449 #if SQLITE_OMIT_PAGER_PRAGMAS 17450 "OMIT_PAGER_PRAGMAS",
17452 #if SQLITE_OMIT_PRAGMA 17455 #if SQLITE_OMIT_PROGRESS_CALLBACK 17456 "OMIT_PROGRESS_CALLBACK",
17458 #if SQLITE_OMIT_QUICKBALANCE 17459 "OMIT_QUICKBALANCE",
17461 #if SQLITE_OMIT_REINDEX 17464 #if SQLITE_OMIT_SCHEMA_PRAGMAS 17465 "OMIT_SCHEMA_PRAGMAS",
17467 #if SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS 17468 "OMIT_SCHEMA_VERSION_PRAGMAS",
17470 #if SQLITE_OMIT_SHARED_CACHE 17471 "OMIT_SHARED_CACHE",
17473 #if SQLITE_OMIT_SUBQUERY 17476 #if SQLITE_OMIT_TCL_VARIABLE 17477 "OMIT_TCL_VARIABLE",
17479 #if SQLITE_OMIT_TEMPDB 17482 #if SQLITE_OMIT_TRACE 17485 #if SQLITE_OMIT_TRIGGER 17488 #if SQLITE_OMIT_TRUNCATE_OPTIMIZATION 17489 "OMIT_TRUNCATE_OPTIMIZATION",
17491 #if SQLITE_OMIT_UTF16 17494 #if SQLITE_OMIT_VACUUM 17497 #if SQLITE_OMIT_VIEW 17500 #if SQLITE_OMIT_VIRTUALTABLE 17501 "OMIT_VIRTUALTABLE",
17503 #if SQLITE_OMIT_WAL 17506 #if SQLITE_OMIT_WSD 17509 #if SQLITE_OMIT_XFER_OPT 17512 #if SQLITE_PERFORMANCE_TRACE 17513 "PERFORMANCE_TRACE",
17515 #if SQLITE_PROXY_DEBUG 17518 #if SQLITE_RTREE_INT_ONLY 17521 #if SQLITE_SECURE_DELETE 17524 #if SQLITE_SMALL_STACK 17530 #if SQLITE_SYSTEM_MALLOC 17536 #if defined(SQLITE_TEMP_STORE) && !defined(SQLITE_TEMP_STORE_xc) 17537 "TEMP_STORE=" CTIMEOPT_VAL(SQLITE_TEMP_STORE),
17542 #if defined(SQLITE_THREADSAFE) 17543 "THREADSAFE=" CTIMEOPT_VAL(SQLITE_THREADSAFE),
17545 #if SQLITE_USE_ALLOCA 17548 #if SQLITE_USER_AUTHENTICATION 17549 "USER_AUTHENTICATION",
17551 #if SQLITE_WIN32_MALLOC 17554 #if SQLITE_ZERO_MALLOC 17566 SQLITE_API
int SQLITE_STDCALL sqlite3_compileoption_used(
const char *zOptName){
17569 #if SQLITE_ENABLE_API_ARMOR 17571 (void)SQLITE_MISUSE_BKPT;
17575 if( sqlite3StrNICmp(zOptName,
"SQLITE_", 7)==0 ) zOptName += 7;
17576 n = sqlite3Strlen30(zOptName);
17580 for(i=0; i<ArraySize(azCompileOpt); i++){
17581 if( sqlite3StrNICmp(zOptName, azCompileOpt[i], n)==0
17582 && sqlite3IsIdChar((
unsigned char)azCompileOpt[i][n])==0
17594 SQLITE_API
const char *SQLITE_STDCALL sqlite3_compileoption_get(
int N){
17595 if( N>=0 && N<ArraySize(azCompileOpt) ){
17596 return azCompileOpt[N];
17640 #ifndef SQLITE_VDBEINT_H 17641 #define SQLITE_VDBEINT_H 17647 #ifndef SQLITE_MAX_SCHEMA_RETRY 17648 # define SQLITE_MAX_SCHEMA_RETRY 50 17655 #if !defined(SQLITE_OMIT_EXPLAIN) || !defined(NDEBUG) \ 17656 || defined(VDBE_PROFILE) || defined(SQLITE_DEBUG) 17657 # define VDBE_DISPLAY_P4 1 17659 # define VDBE_DISPLAY_P4 0 17667 typedef struct VdbeOp Op;
17672 typedef unsigned Bool;
17678 typedef struct Explain Explain;
17681 typedef struct AuxData AuxData;
17684 #define CURTYPE_BTREE 0 17685 #define CURTYPE_SORTER 1 17686 #define CURTYPE_VTAB 2 17687 #define CURTYPE_PSEUDO 3 17700 struct VdbeCursor {
17706 #ifdef SQLITE_DEBUG 17710 Bool isEphemeral:1;
17711 Bool useRandomRowid:1;
17719 int pseudoTableReg;
17720 VdbeSorter *pSorter;
17727 VdbeCursor *pAltCursor;
17729 #ifdef SQLITE_ENABLE_COLUMN_USED_MASK 17778 VdbeFrame *pParent;
17783 VdbeCursor **apCsr;
17798 #define VdbeFrameMem(p) ((Mem *)&((u8 *)p)[ROUND8(sizeof(VdbeFrame))]) 17803 #define CACHE_STALE 0 17829 void (*xDel)(
void*);
17830 #ifdef SQLITE_DEBUG 17840 #define MEMCELLSIZE offsetof(Mem,zMalloc) 17854 #define MEM_Null 0x0001 17855 #define MEM_Str 0x0002 17856 #define MEM_Int 0x0004 17857 #define MEM_Real 0x0008 17858 #define MEM_Blob 0x0010 17859 #define MEM_AffMask 0x001f 17860 #define MEM_RowSet 0x0020 17861 #define MEM_Frame 0x0040 17862 #define MEM_Undefined 0x0080 17863 #define MEM_Cleared 0x0100 17864 #define MEM_TypeMask 0x81ff 17872 #define MEM_Term 0x0200 17873 #define MEM_Dyn 0x0400 17874 #define MEM_Static 0x0800 17875 #define MEM_Ephem 0x1000 17876 #define MEM_Agg 0x2000 17877 #define MEM_Zero 0x4000 17878 #define MEM_Subtype 0x8000 17879 #ifdef SQLITE_OMIT_INCRBLOB 17881 #define MEM_Zero 0x0000 17887 #define VdbeMemDynamic(X) \ 17888 (((X)->flags&(MEM_Agg|MEM_Dyn|MEM_RowSet|MEM_Frame))!=0) 17893 #define MemSetTypeFlag(p, f) \ 17894 ((p)->flags = ((p)->flags&~(MEM_TypeMask|MEM_Zero))|f) 17900 #ifdef SQLITE_DEBUG 17901 #define memIsValid(M) ((M)->flags & MEM_Undefined)==0 17915 void (*xDelete)(
void *);
17960 typedef unsigned bft;
17963 struct ScanStatus {
17992 Vdbe *pPrev,*pNext;
17993 VdbeCursor **apCsr;
18001 #ifdef SQLITE_DEBUG 18008 u8 minWriteFileFormat;
18012 bft usesStmtJournal:1;
18021 #ifndef SQLITE_OMIT_TRACE 18027 i64 nStmtDefImmCons;
18031 VdbeFrame *pDelFrame;
18034 SubProgram *pProgram;
18038 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS 18048 #define VDBE_MAGIC_INIT 0x26bceaa5 18049 #define VDBE_MAGIC_RUN 0xbdf20da3 18050 #define VDBE_MAGIC_HALT 0x519c2973 18051 #define VDBE_MAGIC_DEAD 0xb606c3c8 18063 UnpackedRecord *pUnpacked;
18064 UnpackedRecord *pNewUnpacked;
18075 SQLITE_PRIVATE
void sqlite3VdbeError(Vdbe*,
const char *, ...);
18076 SQLITE_PRIVATE
void sqlite3VdbeFreeCursor(Vdbe *, VdbeCursor*);
18077 void sqliteVdbePopStack(Vdbe*,
int);
18078 SQLITE_PRIVATE
int sqlite3VdbeCursorMoveto(VdbeCursor**,
int*);
18079 SQLITE_PRIVATE
int sqlite3VdbeCursorRestore(VdbeCursor*);
18080 #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE) 18081 SQLITE_PRIVATE
void sqlite3VdbePrintOp(FILE*,
int, Op*);
18083 SQLITE_PRIVATE u32 sqlite3VdbeSerialTypeLen(u32);
18084 SQLITE_PRIVATE u8 sqlite3VdbeOneByteSerialTypeLen(u8);
18085 SQLITE_PRIVATE u32 sqlite3VdbeSerialType(Mem*,
int, u32*);
18086 SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(
unsigned char*, Mem*, u32);
18087 SQLITE_PRIVATE u32 sqlite3VdbeSerialGet(
const unsigned char*, u32, Mem*);
18088 SQLITE_PRIVATE
void sqlite3VdbeDeleteAuxData(
sqlite3*, AuxData**,
int,
int);
18090 int sqlite2BtreeKeyCompare(BtCursor *,
const void *,
int,
int,
int *);
18091 SQLITE_PRIVATE
int sqlite3VdbeIdxKeyCompare(
sqlite3*,VdbeCursor*,UnpackedRecord*,
int*);
18092 SQLITE_PRIVATE
int sqlite3VdbeIdxRowid(
sqlite3*, BtCursor*, i64*);
18093 SQLITE_PRIVATE
int sqlite3VdbeExec(Vdbe*);
18094 SQLITE_PRIVATE
int sqlite3VdbeList(Vdbe*);
18095 SQLITE_PRIVATE
int sqlite3VdbeHalt(Vdbe*);
18096 SQLITE_PRIVATE
int sqlite3VdbeChangeEncoding(Mem *,
int);
18097 SQLITE_PRIVATE
int sqlite3VdbeMemTooBig(Mem*);
18098 SQLITE_PRIVATE
int sqlite3VdbeMemCopy(Mem*,
const Mem*);
18099 SQLITE_PRIVATE
void sqlite3VdbeMemShallowCopy(Mem*,
const Mem*,
int);
18100 SQLITE_PRIVATE
void sqlite3VdbeMemMove(Mem*, Mem*);
18101 SQLITE_PRIVATE
int sqlite3VdbeMemNulTerminate(Mem*);
18102 SQLITE_PRIVATE
int sqlite3VdbeMemSetStr(Mem*,
const char*,
int, u8,
void(*)(
void*));
18103 SQLITE_PRIVATE
void sqlite3VdbeMemSetInt64(Mem*, i64);
18104 #ifdef SQLITE_OMIT_FLOATING_POINT 18105 # define sqlite3VdbeMemSetDouble sqlite3VdbeMemSetInt64 18107 SQLITE_PRIVATE
void sqlite3VdbeMemSetDouble(Mem*,
double);
18109 SQLITE_PRIVATE
void sqlite3VdbeMemInit(Mem*,
sqlite3*,u16);
18110 SQLITE_PRIVATE
void sqlite3VdbeMemSetNull(Mem*);
18111 SQLITE_PRIVATE
void sqlite3VdbeMemSetZeroBlob(Mem*,
int);
18112 SQLITE_PRIVATE
void sqlite3VdbeMemSetRowSet(Mem*);
18113 SQLITE_PRIVATE
int sqlite3VdbeMemMakeWriteable(Mem*);
18114 SQLITE_PRIVATE
int sqlite3VdbeMemStringify(Mem*, u8, u8);
18115 SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem*);
18116 SQLITE_PRIVATE
int sqlite3VdbeMemIntegerify(Mem*);
18117 SQLITE_PRIVATE
double sqlite3VdbeRealValue(Mem*);
18118 SQLITE_PRIVATE
void sqlite3VdbeIntegerAffinity(Mem*);
18119 SQLITE_PRIVATE
int sqlite3VdbeMemRealify(Mem*);
18120 SQLITE_PRIVATE
int sqlite3VdbeMemNumerify(Mem*);
18121 SQLITE_PRIVATE
void sqlite3VdbeMemCast(Mem*,u8,u8);
18122 SQLITE_PRIVATE
int sqlite3VdbeMemFromBtree(BtCursor*,u32,u32,
int,Mem*);
18123 SQLITE_PRIVATE
void sqlite3VdbeMemRelease(Mem *p);
18124 SQLITE_PRIVATE
int sqlite3VdbeMemFinalize(Mem*, FuncDef*);
18125 SQLITE_PRIVATE
const char *sqlite3OpcodeName(
int);
18126 SQLITE_PRIVATE
int sqlite3VdbeMemGrow(Mem *pMem,
int n,
int preserve);
18127 SQLITE_PRIVATE
int sqlite3VdbeMemClearAndResize(Mem *pMem,
int n);
18128 SQLITE_PRIVATE
int sqlite3VdbeCloseStatement(Vdbe *,
int);
18129 SQLITE_PRIVATE
void sqlite3VdbeFrameDelete(VdbeFrame*);
18130 SQLITE_PRIVATE
int sqlite3VdbeFrameRestore(VdbeFrame *);
18131 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK 18132 SQLITE_PRIVATE
void sqlite3VdbePreUpdateHook(Vdbe*,VdbeCursor*,
int,
const char*,Table*,i64,
int);
18134 SQLITE_PRIVATE
int sqlite3VdbeTransferError(Vdbe *p);
18136 SQLITE_PRIVATE
int sqlite3VdbeSorterInit(
sqlite3 *,
int, VdbeCursor *);
18137 SQLITE_PRIVATE
void sqlite3VdbeSorterReset(
sqlite3 *, VdbeSorter *);
18138 SQLITE_PRIVATE
void sqlite3VdbeSorterClose(
sqlite3 *, VdbeCursor *);
18139 SQLITE_PRIVATE
int sqlite3VdbeSorterRowkey(
const VdbeCursor *, Mem *);
18140 SQLITE_PRIVATE
int sqlite3VdbeSorterNext(
sqlite3 *,
const VdbeCursor *,
int *);
18141 SQLITE_PRIVATE
int sqlite3VdbeSorterRewind(
const VdbeCursor *,
int *);
18142 SQLITE_PRIVATE
int sqlite3VdbeSorterWrite(
const VdbeCursor *, Mem *);
18143 SQLITE_PRIVATE
int sqlite3VdbeSorterCompare(
const VdbeCursor *, Mem *,
int,
int *);
18145 #if !defined(SQLITE_OMIT_SHARED_CACHE) 18146 SQLITE_PRIVATE
void sqlite3VdbeEnter(Vdbe*);
18148 # define sqlite3VdbeEnter(X) 18151 #if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0 18152 SQLITE_PRIVATE
void sqlite3VdbeLeave(Vdbe*);
18154 # define sqlite3VdbeLeave(X) 18157 #ifdef SQLITE_DEBUG 18158 SQLITE_PRIVATE
void sqlite3VdbeMemAboutToChange(Vdbe*,Mem*);
18159 SQLITE_PRIVATE
int sqlite3VdbeCheckMemInvariants(Mem*);
18162 #ifndef SQLITE_OMIT_FOREIGN_KEY 18163 SQLITE_PRIVATE
int sqlite3VdbeCheckFk(Vdbe *,
int);
18165 # define sqlite3VdbeCheckFk(p,i) 0 18168 SQLITE_PRIVATE
int sqlite3VdbeMemTranslate(Mem*, u8);
18169 #ifdef SQLITE_DEBUG 18170 SQLITE_PRIVATE
void sqlite3VdbePrintSql(Vdbe*);
18171 SQLITE_PRIVATE
void sqlite3VdbeMemPrettyPrint(Mem *pMem,
char *zBuf);
18173 SQLITE_PRIVATE
int sqlite3VdbeMemHandleBom(Mem *pMem);
18175 #ifndef SQLITE_OMIT_INCRBLOB 18176 SQLITE_PRIVATE
int sqlite3VdbeMemExpandBlob(Mem *);
18177 #define ExpandBlob(P) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0) 18179 #define sqlite3VdbeMemExpandBlob(x) SQLITE_OK 18180 #define ExpandBlob(P) SQLITE_OK 18191 #if SQLITE_PTRSIZE>4 18192 typedef sqlite3_int64 sqlite3StatValueType;
18194 typedef u32 sqlite3StatValueType;
18196 typedef struct sqlite3StatType sqlite3StatType;
18197 static SQLITE_WSD
struct sqlite3StatType {
18198 sqlite3StatValueType nowValue[10];
18199 sqlite3StatValueType mxValue[10];
18200 } sqlite3Stat = { {0,}, {0,} };
18206 static const char statMutex[] = {
18226 #ifdef SQLITE_OMIT_WSD 18227 # define wsdStatInit sqlite3StatType *x = &GLOBAL(sqlite3StatType,sqlite3Stat) 18228 # define wsdStat x[0] 18230 # define wsdStatInit 18231 # define wsdStat sqlite3Stat 18238 SQLITE_PRIVATE sqlite3_int64 sqlite3StatusValue(
int op){
18240 assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
18241 assert( op>=0 && op<ArraySize(statMutex) );
18242 assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex()
18243 : sqlite3MallocMutex()) );
18244 return wsdStat.nowValue[op];
18258 SQLITE_PRIVATE
void sqlite3StatusUp(
int op,
int N){
18260 assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
18261 assert( op>=0 && op<ArraySize(statMutex) );
18262 assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex()
18263 : sqlite3MallocMutex()) );
18264 wsdStat.nowValue[op] += N;
18265 if( wsdStat.nowValue[op]>wsdStat.mxValue[op] ){
18266 wsdStat.mxValue[op] = wsdStat.nowValue[op];
18269 SQLITE_PRIVATE
void sqlite3StatusDown(
int op,
int N){
18272 assert( op>=0 && op<ArraySize(statMutex) );
18273 assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex()
18274 : sqlite3MallocMutex()) );
18275 assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
18276 wsdStat.nowValue[op] -= N;
18283 SQLITE_PRIVATE
void sqlite3StatusHighwater(
int op,
int X){
18284 sqlite3StatValueType newValue;
18287 newValue = (sqlite3StatValueType)X;
18288 assert( op>=0 && op<ArraySize(wsdStat.nowValue) );
18289 assert( op>=0 && op<ArraySize(statMutex) );
18290 assert( sqlite3_mutex_held(statMutex[op] ? sqlite3Pcache1Mutex()
18291 : sqlite3MallocMutex()) );
18292 assert( op==SQLITE_STATUS_MALLOC_SIZE
18293 || op==SQLITE_STATUS_PAGECACHE_SIZE
18294 || op==SQLITE_STATUS_SCRATCH_SIZE
18295 || op==SQLITE_STATUS_PARSER_STACK );
18296 if( newValue>wsdStat.mxValue[op] ){
18297 wsdStat.mxValue[op] = newValue;
18304 SQLITE_API
int SQLITE_STDCALL sqlite3_status64(
18306 sqlite3_int64 *pCurrent,
18307 sqlite3_int64 *pHighwater,
18312 if( op<0 || op>=ArraySize(wsdStat.nowValue) ){
18313 return SQLITE_MISUSE_BKPT;
18315 #ifdef SQLITE_ENABLE_API_ARMOR 18316 if( pCurrent==0 || pHighwater==0 )
return SQLITE_MISUSE_BKPT;
18318 pMutex = statMutex[op] ? sqlite3Pcache1Mutex() : sqlite3MallocMutex();
18319 sqlite3_mutex_enter(pMutex);
18320 *pCurrent = wsdStat.nowValue[op];
18321 *pHighwater = wsdStat.mxValue[op];
18323 wsdStat.mxValue[op] = wsdStat.nowValue[op];
18325 sqlite3_mutex_leave(pMutex);
18329 SQLITE_API
int SQLITE_STDCALL sqlite3_status(
int op,
int *pCurrent,
int *pHighwater,
int resetFlag){
18330 sqlite3_int64 iCur = 0, iHwtr = 0;
18332 #ifdef SQLITE_ENABLE_API_ARMOR 18333 if( pCurrent==0 || pHighwater==0 )
return SQLITE_MISUSE_BKPT;
18335 rc = sqlite3_status64(op, &iCur, &iHwtr, resetFlag);
18337 *pCurrent = (int)iCur;
18338 *pHighwater = (int)iHwtr;
18346 SQLITE_API
int SQLITE_STDCALL sqlite3_db_status(
18353 int rc = SQLITE_OK;
18354 #ifdef SQLITE_ENABLE_API_ARMOR 18355 if( !sqlite3SafetyCheckOk(db) || pCurrent==0|| pHighwater==0 ){
18356 return SQLITE_MISUSE_BKPT;
18359 sqlite3_mutex_enter(db->mutex);
18361 case SQLITE_DBSTATUS_LOOKASIDE_USED: {
18362 *pCurrent = db->lookaside.nOut;
18363 *pHighwater = db->lookaside.mxOut;
18365 db->lookaside.mxOut = db->lookaside.nOut;
18370 case SQLITE_DBSTATUS_LOOKASIDE_HIT:
18371 case SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE:
18372 case SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL: {
18373 testcase( op==SQLITE_DBSTATUS_LOOKASIDE_HIT );
18374 testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE );
18375 testcase( op==SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL );
18376 assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)>=0 );
18377 assert( (op-SQLITE_DBSTATUS_LOOKASIDE_HIT)<3 );
18379 *pHighwater = db->lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT];
18381 db->lookaside.anStat[op - SQLITE_DBSTATUS_LOOKASIDE_HIT] = 0;
18391 case SQLITE_DBSTATUS_CACHE_USED_SHARED:
18392 case SQLITE_DBSTATUS_CACHE_USED: {
18395 sqlite3BtreeEnterAll(db);
18396 for(i=0; i<db->nDb; i++){
18397 Btree *pBt = db->aDb[i].pBt;
18399 Pager *pPager = sqlite3BtreePager(pBt);
18400 int nByte = sqlite3PagerMemUsed(pPager);
18401 if( op==SQLITE_DBSTATUS_CACHE_USED_SHARED ){
18402 nByte = nByte / sqlite3BtreeConnectionCount(pBt);
18404 totalUsed += nByte;
18407 sqlite3BtreeLeaveAll(db);
18408 *pCurrent = totalUsed;
18418 case SQLITE_DBSTATUS_SCHEMA_USED: {
18422 sqlite3BtreeEnterAll(db);
18423 db->pnBytesFreed = &nByte;
18424 for(i=0; i<db->nDb; i++){
18425 Schema *pSchema = db->aDb[i].pSchema;
18426 if( ALWAYS(pSchema!=0) ){
18429 nByte += sqlite3GlobalConfig.m.xRoundup(
sizeof(HashElem)) * (
18430 pSchema->tblHash.count
18431 + pSchema->trigHash.count
18432 + pSchema->idxHash.count
18433 + pSchema->fkeyHash.count
18435 nByte += sqlite3_msize(pSchema->tblHash.ht);
18436 nByte += sqlite3_msize(pSchema->trigHash.ht);
18437 nByte += sqlite3_msize(pSchema->idxHash.ht);
18438 nByte += sqlite3_msize(pSchema->fkeyHash.ht);
18440 for(p=sqliteHashFirst(&pSchema->trigHash); p; p=sqliteHashNext(p)){
18441 sqlite3DeleteTrigger(db, (Trigger*)sqliteHashData(p));
18443 for(p=sqliteHashFirst(&pSchema->tblHash); p; p=sqliteHashNext(p)){
18444 sqlite3DeleteTable(db, (Table *)sqliteHashData(p));
18448 db->pnBytesFreed = 0;
18449 sqlite3BtreeLeaveAll(db);
18461 case SQLITE_DBSTATUS_STMT_USED: {
18462 struct Vdbe *pVdbe;
18465 db->pnBytesFreed = &nByte;
18466 for(pVdbe=db->pVdbe; pVdbe; pVdbe=pVdbe->pNext){
18467 sqlite3VdbeClearObject(db, pVdbe);
18468 sqlite3DbFree(db, pVdbe);
18470 db->pnBytesFreed = 0;
18483 case SQLITE_DBSTATUS_CACHE_HIT:
18484 case SQLITE_DBSTATUS_CACHE_MISS:
18485 case SQLITE_DBSTATUS_CACHE_WRITE:{
18488 assert( SQLITE_DBSTATUS_CACHE_MISS==SQLITE_DBSTATUS_CACHE_HIT+1 );
18489 assert( SQLITE_DBSTATUS_CACHE_WRITE==SQLITE_DBSTATUS_CACHE_HIT+2 );
18491 for(i=0; i<db->nDb; i++){
18492 if( db->aDb[i].pBt ){
18493 Pager *pPager = sqlite3BtreePager(db->aDb[i].pBt);
18494 sqlite3PagerCacheStat(pPager, op, resetFlag, &nRet);
18508 case SQLITE_DBSTATUS_DEFERRED_FKS: {
18510 *pCurrent = db->nDeferredImmCons>0 || db->nDeferredCons>0;
18518 sqlite3_mutex_leave(db->mutex);
18574 #ifndef SQLITE_OMIT_DATETIME_FUNCS 18581 #if !defined(SQLITE_OMIT_LOCALTIME) && defined(_WIN32_WCE) && \ 18582 (!defined(SQLITE_MSVC_LOCALTIME_API) || !SQLITE_MSVC_LOCALTIME_API) 18583 struct tm *__cdecl localtime(
const time_t *);
18631 static int getDigits(
const char *zDate,
const char *zFormat, ...){
18634 static const u16 aMx[] = { 12, 14, 24, 31, 59, 9999 };
18638 va_start(ap, zFormat);
18640 char N = zFormat[0] -
'0';
18641 char min = zFormat[1] -
'0';
18645 assert( zFormat[2]>=
'a' && zFormat[2]<=
'f' );
18646 max = aMx[zFormat[2] -
'a'];
18647 nextC = zFormat[3];
18650 if( !sqlite3Isdigit(*zDate) ){
18651 goto end_getDigits;
18653 val = val*10 + *zDate -
'0';
18656 if( val<(
int)min || val>(
int)max || (nextC!=0 && nextC!=*zDate) ){
18657 goto end_getDigits;
18659 *va_arg(ap,
int*) = val;
18685 static int parseTimezone(
const char *zDate, DateTime *p){
18689 while( sqlite3Isspace(*zDate) ){ zDate++; }
18694 }
else if( c==
'+' ){
18696 }
else if( c==
'Z' || c==
'z' ){
18703 if( getDigits(zDate,
"20b:20e", &nHr, &nMn)!=2 ){
18707 p->tz = sgn*(nMn + nHr*60);
18709 while( sqlite3Isspace(*zDate) ){ zDate++; }
18721 static int parseHhMmSs(
const char *zDate, DateTime *p){
18724 if( getDigits(zDate,
"20c:20e", &h, &m)!=2 ){
18730 if( getDigits(zDate,
"20e", &s)!=1 ){
18734 if( *zDate==
'.' && sqlite3Isdigit(zDate[1]) ){
18735 double rScale = 1.0;
18737 while( sqlite3Isdigit(*zDate) ){
18738 ms = ms*10.0 + *zDate -
'0';
18752 if( parseTimezone(zDate, p) )
return 1;
18753 p->validTZ = (p->tz!=0)?1:0;
18763 static void computeJD(DateTime *p){
18764 int Y, M, D, A, B, X1, X2;
18766 if( p->validJD )
return;
18782 X1 = 36525*(Y+4716)/100;
18783 X2 = 306001*(M+1)/10000;
18784 p->iJD = (sqlite3_int64)((X1 + X2 + D + B - 1524.5 ) * 86400000);
18787 p->iJD += p->h*3600000 + p->m*60000 + (sqlite3_int64)(p->s*1000);
18789 p->iJD -= p->tz*60000;
18809 static int parseYyyyMmDd(
const char *zDate, DateTime *p){
18812 if( zDate[0]==
'-' ){
18818 if( getDigits(zDate,
"40f-21a-21d", &Y, &M, &D)!=3 ){
18822 while( sqlite3Isspace(*zDate) ||
'T'==*(u8*)zDate ){ zDate++; }
18823 if( parseHhMmSs(zDate, p)==0 ){
18825 }
else if( *zDate==0 ){
18832 p->Y = neg ? -Y : Y;
18846 static int setDateTimeToCurrent(
sqlite3_context *context, DateTime *p){
18847 p->iJD = sqlite3StmtCurrentTime(context);
18872 static int parseDateOrTime(
18878 if( parseYyyyMmDd(zDate,p)==0 ){
18880 }
else if( parseHhMmSs(zDate, p)==0 ){
18882 }
else if( sqlite3StrICmp(zDate,
"now")==0){
18883 return setDateTimeToCurrent(context, p);
18884 }
else if( sqlite3AtoF(zDate, &r, sqlite3Strlen30(zDate), SQLITE_UTF8) ){
18885 p->iJD = (sqlite3_int64)(r*86400000.0 + 0.5);
18895 static void computeYMD(DateTime *p){
18896 int Z, A, B, C, D, E, X1;
18897 if( p->validYMD )
return;
18903 Z = (int)((p->iJD + 43200000)/86400000);
18904 A = (int)((Z - 1867216.25)/36524.25);
18905 A = Z + 1 + A - (A/4);
18907 C = (int)((B - 122.1)/365.25);
18908 D = (36525*(C&32767))/100;
18909 E = (int)((B-D)/30.6001);
18910 X1 = (int)(30.6001*E);
18912 p->M = E<14 ? E-1 : E-13;
18913 p->Y = p->M>2 ? C - 4716 : C - 4715;
18921 static void computeHMS(DateTime *p){
18923 if( p->validHMS )
return;
18925 s = (int)((p->iJD + 43200000) % 86400000);
18932 p->s += s - p->m*60;
18939 static void computeYMD_HMS(DateTime *p){
18947 static void clearYMD_HMS_TZ(DateTime *p){
18953 #ifndef SQLITE_OMIT_LOCALTIME 18966 #if !HAVE_LOCALTIME_R && !HAVE_LOCALTIME_S \ 18967 && defined(_MSC_VER) && defined(_CRT_INSECURE_DEPRECATE) 18968 #undef HAVE_LOCALTIME_S 18969 #define HAVE_LOCALTIME_S 1 18985 static int osLocaltime(time_t *t,
struct tm *pTm){
18987 #if !HAVE_LOCALTIME_R && !HAVE_LOCALTIME_S 18989 #if SQLITE_THREADSAFE>0 18990 sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
18992 sqlite3_mutex_enter(mutex);
18994 #ifndef SQLITE_OMIT_BUILTIN_TEST 18995 if( sqlite3GlobalConfig.bLocaltimeFault ) pX = 0;
18997 if( pX ) *pTm = *pX;
18998 sqlite3_mutex_leave(mutex);
19001 #ifndef SQLITE_OMIT_BUILTIN_TEST 19002 if( sqlite3GlobalConfig.bLocaltimeFault )
return 1;
19004 #if HAVE_LOCALTIME_R 19005 rc = localtime_r(t, pTm)==0;
19007 rc = localtime_s(pTm, t);
19015 #ifndef SQLITE_OMIT_LOCALTIME 19024 static sqlite3_int64 localtimeOffset(
19034 memset(&sLocal, 0,
sizeof(sLocal));
19037 computeYMD_HMS(&x);
19038 if( x.Y<1971 || x.Y>=2038 ){
19051 int s = (int)(x.s + 0.5);
19057 t = (time_t)(x.iJD/1000 - 21086676*(i64)10000);
19058 if( osLocaltime(&t, &sLocal) ){
19059 sqlite3_result_error(pCtx,
"local time unavailable", -1);
19060 *pRc = SQLITE_ERROR;
19063 y.Y = sLocal.tm_year + 1900;
19064 y.M = sLocal.tm_mon + 1;
19065 y.D = sLocal.tm_mday;
19066 y.h = sLocal.tm_hour;
19067 y.m = sLocal.tm_min;
19068 y.s = sLocal.tm_sec;
19075 return y.iJD - x.iJD;
19103 static int parseModifier(
sqlite3_context *pCtx,
const char *zMod, DateTime *p){
19109 for(n=0; n<ArraySize(zBuf)-1 && zMod[n]; n++){
19110 z[n] = (char)sqlite3UpperToLower[(u8)zMod[n]];
19114 #ifndef SQLITE_OMIT_LOCALTIME 19121 if( strcmp(z,
"localtime")==0 ){
19123 p->iJD += localtimeOffset(p, pCtx, &rc);
19124 clearYMD_HMS_TZ(p);
19136 if( strcmp(z,
"unixepoch")==0 && p->validJD ){
19137 p->iJD = (p->iJD + 43200)/86400 + 21086676*(i64)10000000;
19138 clearYMD_HMS_TZ(p);
19141 #ifndef SQLITE_OMIT_LOCALTIME 19142 else if( strcmp(z,
"utc")==0 ){
19146 c1 = localtimeOffset(p, pCtx, &rc);
19147 if( rc==SQLITE_OK ){
19149 clearYMD_HMS_TZ(p);
19150 p->iJD += c1 - localtimeOffset(p, pCtx, &rc);
19168 if( strncmp(z,
"weekday ", 8)==0
19169 && sqlite3AtoF(&z[8], &r, sqlite3Strlen30(&z[8]), SQLITE_UTF8)
19170 && (n=(
int)r)==r && n>=0 && r<7 ){
19176 Z = ((p->iJD + 129600000)/86400000) % 7;
19178 p->iJD += (n - Z)*86400000;
19179 clearYMD_HMS_TZ(p);
19191 if( strncmp(z,
"start of ", 9)!=0 )
break;
19199 if( strcmp(z,
"month")==0 ){
19202 }
else if( strcmp(z,
"year")==0 ){
19207 }
else if( strcmp(z,
"day")==0 ){
19225 for(n=1; z[n] && z[n]!=
':' && !sqlite3Isspace(z[n]); n++){}
19226 if( !sqlite3AtoF(z, &r, n, SQLITE_UTF8) ){
19236 const char *z2 = z;
19239 if( !sqlite3Isdigit(*z2) ) z2++;
19240 memset(&tx, 0,
sizeof(tx));
19241 if( parseHhMmSs(z2, &tx) )
break;
19243 tx.iJD -= 43200000;
19244 day = tx.iJD/86400000;
19245 tx.iJD -= day*86400000;
19246 if( z[0]==
'-' ) tx.iJD = -tx.iJD;
19248 clearYMD_HMS_TZ(p);
19254 while( sqlite3Isspace(*z) ) z++;
19255 n = sqlite3Strlen30(z);
19256 if( n>10 || n<3 )
break;
19257 if( z[n-1]==
's' ){ z[n-1] = 0; n--; }
19260 rRounder = r<0 ? -0.5 : +0.5;
19261 if( n==3 && strcmp(z,
"day")==0 ){
19262 p->iJD += (sqlite3_int64)(r*86400000.0 + rRounder);
19263 }
else if( n==4 && strcmp(z,
"hour")==0 ){
19264 p->iJD += (sqlite3_int64)(r*(86400000.0/24.0) + rRounder);
19265 }
else if( n==6 && strcmp(z,
"minute")==0 ){
19266 p->iJD += (sqlite3_int64)(r*(86400000.0/(24.0*60.0)) + rRounder);
19267 }
else if( n==6 && strcmp(z,
"second")==0 ){
19268 p->iJD += (sqlite3_int64)(r*(86400000.0/(24.0*60.0*60.0)) + rRounder);
19269 }
else if( n==5 && strcmp(z,
"month")==0 ){
19273 x = p->M>0 ? (p->M-1)/12 : (p->M-12)/12;
19280 p->iJD += (sqlite3_int64)((r - y)*30.0*86400000.0 + rRounder);
19282 }
else if( n==4 && strcmp(z,
"year")==0 ){
19289 p->iJD += (sqlite3_int64)((r - y)*365.0*86400000.0 + rRounder);
19294 clearYMD_HMS_TZ(p);
19320 const unsigned char *z;
19322 memset(p, 0,
sizeof(*p));
19324 return setDateTimeToCurrent(context, p);
19326 if( (eType = sqlite3_value_type(argv[0]))==SQLITE_FLOAT
19327 || eType==SQLITE_INTEGER ){
19328 p->iJD = (sqlite3_int64)(sqlite3_value_double(argv[0])*86400000.0 + 0.5);
19331 z = sqlite3_value_text(argv[0]);
19332 if( !z || parseDateOrTime(context, (
char*)z, p) ){
19336 for(i=1; i<argc; i++){
19337 z = sqlite3_value_text(argv[i]);
19338 if( z==0 || parseModifier(context, (
char*)z, p) )
return 1;
19354 static void juliandayFunc(
19360 if( isDate(context, argc, argv, &x)==0 ){
19362 sqlite3_result_double(context, x.iJD/86400000.0);
19371 static void datetimeFunc(
19377 if( isDate(context, argc, argv, &x)==0 ){
19379 computeYMD_HMS(&x);
19380 sqlite3_snprintf(
sizeof(zBuf), zBuf,
"%04d-%02d-%02d %02d:%02d:%02d",
19381 x.Y, x.M, x.D, x.h, x.m, (
int)(x.s));
19382 sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
19391 static void timeFunc(
19397 if( isDate(context, argc, argv, &x)==0 ){
19400 sqlite3_snprintf(
sizeof(zBuf), zBuf,
"%02d:%02d:%02d", x.h, x.m, (
int)x.s);
19401 sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
19410 static void dateFunc(
19416 if( isDate(context, argc, argv, &x)==0 ){
19419 sqlite3_snprintf(
sizeof(zBuf), zBuf,
"%04d-%02d-%02d", x.Y, x.M, x.D);
19420 sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
19443 static void strftimeFunc(
19455 if( argc==0 )
return;
19456 zFmt = (
const char*)sqlite3_value_text(argv[0]);
19457 if( zFmt==0 || isDate(context, argc-1, argv+1, &x) )
return;
19458 db = sqlite3_context_db_handle(context);
19459 for(i=0, n=1; zFmt[i]; i++, n++){
19460 if( zFmt[i]==
'%' ){
19461 switch( zFmt[i+1] ){
19492 testcase( n==
sizeof(zBuf)-1 );
19493 testcase( n==
sizeof(zBuf) );
19494 testcase( n==(u64)db->aLimit[SQLITE_LIMIT_LENGTH]+1 );
19495 testcase( n==(u64)db->aLimit[SQLITE_LIMIT_LENGTH] );
19496 if( n<
sizeof(zBuf) ){
19498 }
else if( n>(u64)db->aLimit[SQLITE_LIMIT_LENGTH] ){
19499 sqlite3_result_error_toobig(context);
19502 z = sqlite3DbMallocRawNN(db, (
int)n);
19504 sqlite3_result_error_nomem(context);
19509 computeYMD_HMS(&x);
19510 for(i=j=0; zFmt[i]; i++){
19511 if( zFmt[i]!=
'%' ){
19516 case 'd': sqlite3_snprintf(3, &z[j],
"%02d",x.D); j+=2;
break;
19519 if( s>59.999 ) s = 59.999;
19520 sqlite3_snprintf(7, &z[j],
"%06.3f", s);
19521 j += sqlite3Strlen30(&z[j]);
19524 case 'H': sqlite3_snprintf(3, &z[j],
"%02d",x.h); j+=2;
break;
19533 nDay = (int)((x.iJD-y.iJD+43200000)/86400000);
19534 if( zFmt[i]==
'W' ){
19536 wd = (int)(((x.iJD+43200000)/86400000)%7);
19537 sqlite3_snprintf(3, &z[j],
"%02d",(nDay+7-wd)/7);
19540 sqlite3_snprintf(4, &z[j],
"%03d",nDay+1);
19546 sqlite3_snprintf(20, &z[j],
"%.16g",x.iJD/86400000.0);
19547 j+=sqlite3Strlen30(&z[j]);
19550 case 'm': sqlite3_snprintf(3, &z[j],
"%02d",x.M); j+=2;
break;
19551 case 'M': sqlite3_snprintf(3, &z[j],
"%02d",x.m); j+=2;
break;
19553 sqlite3_snprintf(30,&z[j],
"%lld",
19554 (i64)(x.iJD/1000 - 21086676*(i64)10000));
19555 j += sqlite3Strlen30(&z[j]);
19558 case 'S': sqlite3_snprintf(3,&z[j],
"%02d",(
int)x.s); j+=2;
break;
19560 z[j++] = (char)(((x.iJD+129600000)/86400000) % 7) +
'0';
19564 sqlite3_snprintf(5,&z[j],
"%04d",x.Y); j+=sqlite3Strlen30(&z[j]);
19567 default: z[j++] =
'%';
break;
19572 sqlite3_result_text(context, z, -1,
19573 z==zBuf ? SQLITE_TRANSIENT : SQLITE_DYNAMIC);
19581 static void ctimeFunc(
19586 UNUSED_PARAMETER2(NotUsed, NotUsed2);
19587 timeFunc(context, 0, 0);
19595 static void cdateFunc(
19600 UNUSED_PARAMETER2(NotUsed, NotUsed2);
19601 dateFunc(context, 0, 0);
19609 static void ctimestampFunc(
19614 UNUSED_PARAMETER2(NotUsed, NotUsed2);
19615 datetimeFunc(context, 0, 0);
19619 #ifdef SQLITE_OMIT_DATETIME_FUNCS 19631 static void currentTimeFunc(
19637 char *zFormat = (
char *)sqlite3_user_data(context);
19643 UNUSED_PARAMETER(argc);
19644 UNUSED_PARAMETER(argv);
19646 iT = sqlite3StmtCurrentTime(context);
19647 if( iT<=0 )
return;
19648 t = iT/1000 - 10000*(sqlite3_int64)21086676;
19650 pTm = gmtime_r(&t, &sNow);
19652 sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
19654 if( pTm ) memcpy(&sNow, pTm,
sizeof(sNow));
19655 sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER));
19658 strftime(zBuf, 20, zFormat, &sNow);
19659 sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);
19669 SQLITE_PRIVATE
void sqlite3RegisterDateTimeFunctions(
void){
19670 static FuncDef aDateTimeFuncs[] = {
19671 #ifndef SQLITE_OMIT_DATETIME_FUNCS 19672 DFUNCTION(julianday, -1, 0, 0, juliandayFunc ),
19673 DFUNCTION(date, -1, 0, 0, dateFunc ),
19674 DFUNCTION(time, -1, 0, 0, timeFunc ),
19675 DFUNCTION(datetime, -1, 0, 0, datetimeFunc ),
19676 DFUNCTION(strftime, -1, 0, 0, strftimeFunc ),
19677 DFUNCTION(current_time, 0, 0, 0, ctimeFunc ),
19678 DFUNCTION(current_timestamp, 0, 0, 0, ctimestampFunc),
19679 DFUNCTION(current_date, 0, 0, 0, cdateFunc ),
19681 STR_FUNCTION(current_time, 0,
"%H:%M:%S", 0, currentTimeFunc),
19682 STR_FUNCTION(current_date, 0,
"%Y-%m-%d", 0, currentTimeFunc),
19683 STR_FUNCTION(current_timestamp, 0,
"%Y-%m-%d %H:%M:%S", 0, currentTimeFunc),
19686 sqlite3InsertBuiltinFuncs(aDateTimeFuncs, ArraySize(aDateTimeFuncs));
19713 #if defined(SQLITE_TEST) 19714 SQLITE_API
int sqlite3_io_error_hit = 0;
19715 SQLITE_API
int sqlite3_io_error_hardhit = 0;
19716 SQLITE_API
int sqlite3_io_error_pending = 0;
19717 SQLITE_API
int sqlite3_io_error_persist = 0;
19718 SQLITE_API
int sqlite3_io_error_benign = 0;
19719 SQLITE_API
int sqlite3_diskfull_pending = 0;
19720 SQLITE_API
int sqlite3_diskfull = 0;
19726 #if defined(SQLITE_TEST) 19727 SQLITE_API
int sqlite3_open_file_count = 0;
19754 #if defined(SQLITE_TEST) 19755 SQLITE_API
int sqlite3_memdebug_vfs_oom_test = 1;
19756 #define DO_OS_MALLOC_TEST(x) \ 19757 if (sqlite3_memdebug_vfs_oom_test && (!x || !sqlite3JournalIsInMemory(x))) { \ 19758 void *pTstAlloc = sqlite3Malloc(10); \ 19759 if (!pTstAlloc) return SQLITE_IOERR_NOMEM_BKPT; \ 19760 sqlite3_free(pTstAlloc); \ 19763 #define DO_OS_MALLOC_TEST(x) 19772 SQLITE_PRIVATE
void sqlite3OsClose(
sqlite3_file *pId){
19773 if( pId->pMethods ){
19774 pId->pMethods->xClose(pId);
19778 SQLITE_PRIVATE
int sqlite3OsRead(
sqlite3_file *
id,
void *pBuf,
int amt, i64 offset){
19779 DO_OS_MALLOC_TEST(
id);
19780 return id->pMethods->xRead(
id, pBuf, amt, offset);
19782 SQLITE_PRIVATE
int sqlite3OsWrite(
sqlite3_file *
id,
const void *pBuf,
int amt, i64 offset){
19783 DO_OS_MALLOC_TEST(
id);
19784 return id->pMethods->xWrite(
id, pBuf, amt, offset);
19786 SQLITE_PRIVATE
int sqlite3OsTruncate(
sqlite3_file *
id, i64 size){
19787 return id->pMethods->xTruncate(
id, size);
19789 SQLITE_PRIVATE
int sqlite3OsSync(
sqlite3_file *
id,
int flags){
19790 DO_OS_MALLOC_TEST(
id);
19791 return id->pMethods->xSync(
id, flags);
19793 SQLITE_PRIVATE
int sqlite3OsFileSize(
sqlite3_file *
id, i64 *pSize){
19794 DO_OS_MALLOC_TEST(
id);
19795 return id->pMethods->xFileSize(
id, pSize);
19797 SQLITE_PRIVATE
int sqlite3OsLock(
sqlite3_file *
id,
int lockType){
19798 DO_OS_MALLOC_TEST(
id);
19799 return id->pMethods->xLock(
id, lockType);
19801 SQLITE_PRIVATE
int sqlite3OsUnlock(
sqlite3_file *
id,
int lockType){
19802 return id->pMethods->xUnlock(
id, lockType);
19804 SQLITE_PRIVATE
int sqlite3OsCheckReservedLock(
sqlite3_file *
id,
int *pResOut){
19805 DO_OS_MALLOC_TEST(
id);
19806 return id->pMethods->xCheckReservedLock(
id, pResOut);
19817 SQLITE_PRIVATE
int sqlite3OsFileControl(
sqlite3_file *
id,
int op,
void *pArg){
19819 if( op!=SQLITE_FCNTL_COMMIT_PHASETWO ){
19830 DO_OS_MALLOC_TEST(
id);
19833 return id->pMethods->xFileControl(
id, op, pArg);
19835 SQLITE_PRIVATE
void sqlite3OsFileControlHint(
sqlite3_file *
id,
int op,
void *pArg){
19836 (void)id->pMethods->xFileControl(
id, op, pArg);
19839 SQLITE_PRIVATE
int sqlite3OsSectorSize(
sqlite3_file *
id){
19840 int (*xSectorSize)(
sqlite3_file*) = id->pMethods->xSectorSize;
19841 return (xSectorSize ? xSectorSize(
id) : SQLITE_DEFAULT_SECTOR_SIZE);
19843 SQLITE_PRIVATE
int sqlite3OsDeviceCharacteristics(
sqlite3_file *
id){
19844 return id->pMethods->xDeviceCharacteristics(
id);
19846 SQLITE_PRIVATE
int sqlite3OsShmLock(
sqlite3_file *
id,
int offset,
int n,
int flags){
19847 return id->pMethods->xShmLock(
id, offset, n, flags);
19849 SQLITE_PRIVATE
void sqlite3OsShmBarrier(
sqlite3_file *
id){
19850 id->pMethods->xShmBarrier(
id);
19852 SQLITE_PRIVATE
int sqlite3OsShmUnmap(
sqlite3_file *
id,
int deleteFlag){
19853 return id->pMethods->xShmUnmap(
id, deleteFlag);
19855 SQLITE_PRIVATE
int sqlite3OsShmMap(
19862 DO_OS_MALLOC_TEST(
id);
19863 return id->pMethods->xShmMap(
id, iPage, pgsz, bExtend, pp);
19866 #if SQLITE_MAX_MMAP_SIZE>0 19868 SQLITE_PRIVATE
int sqlite3OsFetch(
sqlite3_file *
id, i64 iOff,
int iAmt,
void **pp){
19869 DO_OS_MALLOC_TEST(
id);
19870 return id->pMethods->xFetch(
id, iOff, iAmt, pp);
19872 SQLITE_PRIVATE
int sqlite3OsUnfetch(
sqlite3_file *
id, i64 iOff,
void *p){
19873 return id->pMethods->xUnfetch(
id, iOff, p);
19877 SQLITE_PRIVATE
int sqlite3OsFetch(
sqlite3_file *
id, i64 iOff,
int iAmt,
void **pp){
19881 SQLITE_PRIVATE
int sqlite3OsUnfetch(
sqlite3_file *
id, i64 iOff,
void *p){
19890 SQLITE_PRIVATE
int sqlite3OsOpen(
19898 DO_OS_MALLOC_TEST(0);
19903 rc = pVfs->xOpen(pVfs, zPath, pFile, flags & 0x87f7f, pFlagsOut);
19904 assert( rc==SQLITE_OK || pFile->pMethods==0 );
19907 SQLITE_PRIVATE
int sqlite3OsDelete(
sqlite3_vfs *pVfs,
const char *zPath,
int dirSync){
19908 DO_OS_MALLOC_TEST(0);
19909 assert( dirSync==0 || dirSync==1 );
19910 return pVfs->xDelete(pVfs, zPath, dirSync);
19912 SQLITE_PRIVATE
int sqlite3OsAccess(
19918 DO_OS_MALLOC_TEST(0);
19919 return pVfs->xAccess(pVfs, zPath, flags, pResOut);
19921 SQLITE_PRIVATE
int sqlite3OsFullPathname(
19927 DO_OS_MALLOC_TEST(0);
19929 return pVfs->xFullPathname(pVfs, zPath, nPathOut, zPathOut);
19931 #ifndef SQLITE_OMIT_LOAD_EXTENSION 19932 SQLITE_PRIVATE
void *sqlite3OsDlOpen(
sqlite3_vfs *pVfs,
const char *zPath){
19933 return pVfs->xDlOpen(pVfs, zPath);
19935 SQLITE_PRIVATE
void sqlite3OsDlError(
sqlite3_vfs *pVfs,
int nByte,
char *zBufOut){
19936 pVfs->xDlError(pVfs, nByte, zBufOut);
19938 SQLITE_PRIVATE void (*sqlite3OsDlSym(
sqlite3_vfs *pVfs,
void *pHdle,
const char *zSym))(void){
19939 return pVfs->xDlSym(pVfs, pHdle, zSym);
19941 SQLITE_PRIVATE
void sqlite3OsDlClose(
sqlite3_vfs *pVfs,
void *pHandle){
19942 pVfs->xDlClose(pVfs, pHandle);
19945 SQLITE_PRIVATE
int sqlite3OsRandomness(
sqlite3_vfs *pVfs,
int nByte,
char *zBufOut){
19946 return pVfs->xRandomness(pVfs, nByte, zBufOut);
19948 SQLITE_PRIVATE
int sqlite3OsSleep(
sqlite3_vfs *pVfs,
int nMicro){
19949 return pVfs->xSleep(pVfs, nMicro);
19951 SQLITE_PRIVATE
int sqlite3OsGetLastError(
sqlite3_vfs *pVfs){
19952 return pVfs->xGetLastError ? pVfs->xGetLastError(pVfs, 0, 0) : 0;
19954 SQLITE_PRIVATE
int sqlite3OsCurrentTimeInt64(
sqlite3_vfs *pVfs, sqlite3_int64 *pTimeOut){
19962 if( pVfs->iVersion>=2 && pVfs->xCurrentTimeInt64 ){
19963 rc = pVfs->xCurrentTimeInt64(pVfs, pTimeOut);
19966 rc = pVfs->xCurrentTime(pVfs, &r);
19967 *pTimeOut = (sqlite3_int64)(r*86400000.0);
19972 SQLITE_PRIVATE
int sqlite3OsOpenMalloc(
19981 pFile = (
sqlite3_file *)sqlite3MallocZero(pVfs->szOsFile);
19983 rc = sqlite3OsOpen(pVfs, zFile, pFile, flags, pOutFlags);
19984 if( rc!=SQLITE_OK ){
19985 sqlite3_free(pFile);
19990 rc = SQLITE_NOMEM_BKPT;
19994 SQLITE_PRIVATE
void sqlite3OsCloseFree(
sqlite3_file *pFile){
19996 sqlite3OsClose(pFile);
19997 sqlite3_free(pFile);
20006 SQLITE_PRIVATE
int sqlite3OsInit(
void){
20007 void *p = sqlite3_malloc(10);
20008 if( p==0 )
return SQLITE_NOMEM_BKPT;
20010 return sqlite3_os_init();
20017 #define vfsList GLOBAL(sqlite3_vfs *, vfsList) 20023 SQLITE_API
sqlite3_vfs *SQLITE_STDCALL sqlite3_vfs_find(
const char *zVfs){
20025 #if SQLITE_THREADSAFE 20028 #ifndef SQLITE_OMIT_AUTOINIT 20029 int rc = sqlite3_initialize();
20032 #if SQLITE_THREADSAFE 20033 mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
20035 sqlite3_mutex_enter(mutex);
20036 for(pVfs = vfsList; pVfs; pVfs=pVfs->pNext){
20037 if( zVfs==0 )
break;
20038 if( strcmp(zVfs, pVfs->zName)==0 )
break;
20040 sqlite3_mutex_leave(mutex);
20048 assert( sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER)) );
20051 }
else if( vfsList==pVfs ){
20052 vfsList = pVfs->pNext;
20053 }
else if( vfsList ){
20055 while( p->pNext && p->pNext!=pVfs ){
20058 if( p->pNext==pVfs ){
20059 p->pNext = pVfs->pNext;
20069 SQLITE_API
int SQLITE_STDCALL sqlite3_vfs_register(
sqlite3_vfs *pVfs,
int makeDflt){
20071 #ifndef SQLITE_OMIT_AUTOINIT
20072 int rc = sqlite3_initialize();
20073 if( rc )
return rc;
20075 #ifdef SQLITE_ENABLE_API_ARMOR 20076 if( pVfs==0 )
return SQLITE_MISUSE_BKPT;
20079 MUTEX_LOGIC( mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); )
20080 sqlite3_mutex_enter(mutex);
20082 if( makeDflt || vfsList==0 ){
20083 pVfs->pNext = vfsList;
20086 pVfs->pNext = vfsList->pNext;
20087 vfsList->pNext = pVfs;
20090 sqlite3_mutex_leave(mutex);
20097 SQLITE_API
int SQLITE_STDCALL sqlite3_vfs_unregister(
sqlite3_vfs *pVfs){
20098 #if SQLITE_THREADSAFE 20099 sqlite3_mutex *mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
20101 sqlite3_mutex_enter(mutex);
20103 sqlite3_mutex_leave(mutex);
20137 #ifndef SQLITE_OMIT_BUILTIN_TEST 20142 typedef struct BenignMallocHooks BenignMallocHooks;
20143 static SQLITE_WSD
struct BenignMallocHooks {
20144 void (*xBenignBegin)(void);
20145 void (*xBenignEnd)(void);
20146 } sqlite3Hooks = { 0, 0 };
20154 #ifdef SQLITE_OMIT_WSD 20155 # define wsdHooksInit \ 20156 BenignMallocHooks *x = &GLOBAL(BenignMallocHooks,sqlite3Hooks) 20157 # define wsdHooks x[0] 20159 # define wsdHooksInit 20160 # define wsdHooks sqlite3Hooks 20168 SQLITE_PRIVATE
void sqlite3BenignMallocHooks(
20169 void (*xBenignBegin)(
void),
20170 void (*xBenignEnd)(
void)
20173 wsdHooks.xBenignBegin = xBenignBegin;
20174 wsdHooks.xBenignEnd = xBenignEnd;
20182 SQLITE_PRIVATE
void sqlite3BeginBenignMalloc(
void){
20184 if( wsdHooks.xBenignBegin ){
20185 wsdHooks.xBenignBegin();
20188 SQLITE_PRIVATE
void sqlite3EndBenignMalloc(
void){
20190 if( wsdHooks.xBenignEnd ){
20191 wsdHooks.xBenignEnd();
20224 #ifdef SQLITE_ZERO_MALLOC 20229 static void *sqlite3MemMalloc(
int nByte){
return 0; }
20230 static void sqlite3MemFree(
void *pPrior){
return; }
20231 static void *sqlite3MemRealloc(
void *pPrior,
int nByte){
return 0; }
20232 static int sqlite3MemSize(
void *pPrior){
return 0; }
20233 static int sqlite3MemRoundup(
int n){
return n; }
20234 static int sqlite3MemInit(
void *NotUsed){
return SQLITE_OK; }
20235 static void sqlite3MemShutdown(
void *NotUsed){
return; }
20243 SQLITE_PRIVATE
void sqlite3MemSetDefault(
void){
20251 sqlite3MemShutdown,
20254 sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods);
20311 #ifdef SQLITE_SYSTEM_MALLOC 20312 #if defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC) 20318 #include <sys/sysctl.h> 20319 #include <malloc/malloc.h> 20320 #include <libkern/OSAtomic.h> 20321 static malloc_zone_t* _sqliteZone_;
20322 #define SQLITE_MALLOC(x) malloc_zone_malloc(_sqliteZone_, (x)) 20323 #define SQLITE_FREE(x) malloc_zone_free(_sqliteZone_, (x)); 20324 #define SQLITE_REALLOC(x,y) malloc_zone_realloc(_sqliteZone_, (x), (y)) 20325 #define SQLITE_MALLOCSIZE(x) \ 20326 (_sqliteZone_ ? _sqliteZone_->size(_sqliteZone_,x) : malloc_size(x)) 20334 #define SQLITE_MALLOC(x) malloc(x) 20335 #define SQLITE_FREE(x) free(x) 20336 #define SQLITE_REALLOC(x,y) realloc((x),(y)) 20342 #if HAVE_MALLOC_H && HAVE_MALLOC_USABLE_SIZE 20343 # define SQLITE_USE_MALLOC_H 1 20344 # define SQLITE_USE_MALLOC_USABLE_SIZE 1 20351 #elif defined(_MSC_VER) && !defined(SQLITE_WITHOUT_MSIZE) 20352 # define SQLITE_USE_MALLOC_H 20353 # define SQLITE_USE_MSIZE 20363 #if defined(SQLITE_USE_MALLOC_H) 20364 # include <malloc.h> 20365 # if defined(SQLITE_USE_MALLOC_USABLE_SIZE) 20366 # if !defined(SQLITE_MALLOCSIZE) 20367 # define SQLITE_MALLOCSIZE(x) malloc_usable_size(x) 20369 # elif defined(SQLITE_USE_MSIZE) 20370 # if !defined(SQLITE_MALLOCSIZE) 20371 # define SQLITE_MALLOCSIZE _msize 20386 static void *sqlite3MemMalloc(
int nByte){
20387 #ifdef SQLITE_MALLOCSIZE 20388 void *p = SQLITE_MALLOC( nByte );
20390 testcase( sqlite3GlobalConfig.xLog!=0 );
20391 sqlite3_log(SQLITE_NOMEM,
"failed to allocate %u bytes of memory", nByte);
20397 nByte = ROUND8(nByte);
20398 p = SQLITE_MALLOC( nByte+8 );
20403 testcase( sqlite3GlobalConfig.xLog!=0 );
20404 sqlite3_log(SQLITE_NOMEM,
"failed to allocate %u bytes of memory", nByte);
20418 static void sqlite3MemFree(
void *pPrior){
20419 #ifdef SQLITE_MALLOCSIZE 20420 SQLITE_FREE(pPrior);
20422 sqlite3_int64 *p = (sqlite3_int64*)pPrior;
20423 assert( pPrior!=0 );
20433 static int sqlite3MemSize(
void *pPrior){
20434 #ifdef SQLITE_MALLOCSIZE 20435 assert( pPrior!=0 );
20436 return (
int)SQLITE_MALLOCSIZE(pPrior);
20439 assert( pPrior!=0 );
20440 p = (sqlite3_int64*)pPrior;
20456 static void *sqlite3MemRealloc(
void *pPrior,
int nByte){
20457 #ifdef SQLITE_MALLOCSIZE 20458 void *p = SQLITE_REALLOC(pPrior, nByte);
20460 testcase( sqlite3GlobalConfig.xLog!=0 );
20461 sqlite3_log(SQLITE_NOMEM,
20462 "failed memory resize %u to %u bytes",
20463 SQLITE_MALLOCSIZE(pPrior), nByte);
20467 sqlite3_int64 *p = (sqlite3_int64*)pPrior;
20468 assert( pPrior!=0 && nByte>0 );
20469 assert( nByte==ROUND8(nByte) );
20471 p = SQLITE_REALLOC(p, nByte+8 );
20476 testcase( sqlite3GlobalConfig.xLog!=0 );
20477 sqlite3_log(SQLITE_NOMEM,
20478 "failed memory resize %u to %u bytes",
20479 sqlite3MemSize(pPrior), nByte);
20488 static int sqlite3MemRoundup(
int n){
20495 static int sqlite3MemInit(
void *NotUsed){
20496 #if defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC) 20499 if( _sqliteZone_ ){
20502 len =
sizeof(cpuCount);
20504 sysctlbyname(
"hw.ncpu", &cpuCount, &len, NULL, 0);
20507 _sqliteZone_ = malloc_default_zone();
20512 malloc_zone_t* newzone = malloc_create_zone(4096, 0);
20513 malloc_set_zone_name(newzone,
"Sqlite_Heap");
20515 success = OSAtomicCompareAndSwapPtrBarrier(NULL, newzone,
20516 (
void *
volatile *)&_sqliteZone_);
20517 }
while(!_sqliteZone_);
20520 malloc_destroy_zone(newzone);
20524 UNUSED_PARAMETER(NotUsed);
20531 static void sqlite3MemShutdown(
void *NotUsed){
20532 UNUSED_PARAMETER(NotUsed);
20542 SQLITE_PRIVATE
void sqlite3MemSetDefault(
void){
20550 sqlite3MemShutdown,
20553 sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods);
20587 #ifdef SQLITE_MEMDEBUG 20593 extern int backtrace(
void**,
int);
20594 extern void backtrace_symbols_fd(
void*
const*,
int,
int);
20596 # define backtrace(A,B) 1 20597 # define backtrace_symbols_fd(A,B,C) 20614 struct MemBlockHdr {
20616 struct MemBlockHdr *pNext, *pPrev;
20618 char nBacktraceSlots;
20627 #define FOREGUARD 0x80F5E153 20628 #define REARGUARD 0xE4676B53 20633 #define NCSIZE 1000 20651 struct MemBlockHdr *pFirst;
20652 struct MemBlockHdr *pLast;
20658 void (*xBacktrace)(int, int,
void **);
20678 int nAlloc[NCSIZE];
20679 int nCurrent[NCSIZE];
20680 int mxCurrent[NCSIZE];
20688 static void adjustStats(
int iSize,
int increment){
20689 int i = ROUND8(iSize)/8;
20696 if( mem.nCurrent[i]>mem.mxCurrent[i] ){
20697 mem.mxCurrent[i] = mem.nCurrent[i];
20701 assert( mem.nCurrent[i]>=0 );
20711 static struct MemBlockHdr *sqlite3MemsysGetHeader(
void *pAllocation){
20712 struct MemBlockHdr *p;
20717 p = (
struct MemBlockHdr*)pAllocation;
20719 assert( p->iForeGuard==(
int)FOREGUARD );
20720 nReserve = ROUND8(p->iSize);
20721 pInt = (
int*)pAllocation;
20722 pU8 = (u8*)pAllocation;
20723 assert( pInt[nReserve/
sizeof(
int)]==(
int)REARGUARD );
20728 while( nReserve-- > p->iSize ) assert( pU8[nReserve]==0x65 );
20735 static int sqlite3MemSize(
void *p){
20736 struct MemBlockHdr *pHdr;
20740 pHdr = sqlite3MemsysGetHeader(p);
20741 return (
int)pHdr->iSize;
20747 static int sqlite3MemInit(
void *NotUsed){
20748 UNUSED_PARAMETER(NotUsed);
20749 assert( (
sizeof(
struct MemBlockHdr)&7) == 0 );
20750 if( !sqlite3GlobalConfig.bMemstat ){
20753 mem.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
20761 static void sqlite3MemShutdown(
void *NotUsed){
20762 UNUSED_PARAMETER(NotUsed);
20769 static int sqlite3MemRoundup(
int n){
20778 static void randomFill(
char *pBuf,
int nByte){
20779 unsigned int x, y, r;
20780 x = SQLITE_PTR_TO_INT(pBuf);
20782 while( nByte >= 4 ){
20783 x = (x>>1) ^ (-(
int)(x&1) & 0xd0000001);
20784 y = y*1103515245 + 12345;
20790 while( nByte-- > 0 ){
20791 x = (x>>1) ^ (-(
int)(x&1) & 0xd0000001);
20792 y = y*1103515245 + 12345;
20794 *(pBuf++) = r & 0xff;
20801 static void *sqlite3MemMalloc(
int nByte){
20802 struct MemBlockHdr *pHdr;
20809 sqlite3_mutex_enter(mem.mutex);
20810 assert( mem.disallow==0 );
20811 nReserve = ROUND8(nByte);
20812 totalSize = nReserve +
sizeof(*pHdr) +
sizeof(int) +
20813 mem.nBacktrace*
sizeof(
void*) + mem.nTitle;
20814 p = malloc(totalSize);
20817 pBt = (
void**)&z[mem.nTitle];
20818 pHdr = (
struct MemBlockHdr*)&pBt[mem.nBacktrace];
20820 pHdr->pPrev = mem.pLast;
20822 mem.pLast->pNext = pHdr;
20827 pHdr->iForeGuard = FOREGUARD;
20828 pHdr->eType = MEMTYPE_HEAP;
20829 pHdr->nBacktraceSlots = mem.nBacktrace;
20830 pHdr->nTitle = mem.nTitle;
20831 if( mem.nBacktrace ){
20833 pHdr->nBacktrace = backtrace(aAddr, mem.nBacktrace+1)-1;
20834 memcpy(pBt, &aAddr[1], pHdr->nBacktrace*
sizeof(
void*));
20836 if( mem.xBacktrace ){
20837 mem.xBacktrace(nByte, pHdr->nBacktrace-1, &aAddr[1]);
20840 pHdr->nBacktrace = 0;
20843 memcpy(z, mem.zTitle, mem.nTitle);
20845 pHdr->iSize = nByte;
20846 adjustStats(nByte, +1);
20847 pInt = (
int*)&pHdr[1];
20848 pInt[nReserve/
sizeof(int)] = REARGUARD;
20849 randomFill((
char*)pInt, nByte);
20850 memset(((
char*)pInt)+nByte, 0x65, nReserve-nByte);
20853 sqlite3_mutex_leave(mem.mutex);
20860 static void sqlite3MemFree(
void *pPrior){
20861 struct MemBlockHdr *pHdr;
20864 assert( sqlite3GlobalConfig.bMemstat || sqlite3GlobalConfig.bCoreMutex==0
20866 pHdr = sqlite3MemsysGetHeader(pPrior);
20867 pBt = (
void**)pHdr;
20868 pBt -= pHdr->nBacktraceSlots;
20869 sqlite3_mutex_enter(mem.mutex);
20871 assert( pHdr->pPrev->pNext==pHdr );
20872 pHdr->pPrev->pNext = pHdr->pNext;
20874 assert( mem.pFirst==pHdr );
20875 mem.pFirst = pHdr->pNext;
20878 assert( pHdr->pNext->pPrev==pHdr );
20879 pHdr->pNext->pPrev = pHdr->pPrev;
20881 assert( mem.pLast==pHdr );
20882 mem.pLast = pHdr->pPrev;
20886 adjustStats((
int)pHdr->iSize, -1);
20887 randomFill(z,
sizeof(
void*)*pHdr->nBacktraceSlots +
sizeof(*pHdr) +
20888 (
int)pHdr->iSize +
sizeof(
int) + pHdr->nTitle);
20890 sqlite3_mutex_leave(mem.mutex);
20902 static void *sqlite3MemRealloc(
void *pPrior,
int nByte){
20903 struct MemBlockHdr *pOldHdr;
20905 assert( mem.disallow==0 );
20906 assert( (nByte & 7)==0 );
20907 pOldHdr = sqlite3MemsysGetHeader(pPrior);
20908 pNew = sqlite3MemMalloc(nByte);
20910 memcpy(pNew, pPrior, (
int)(nByte<pOldHdr->iSize ? nByte : pOldHdr->iSize));
20911 if( nByte>pOldHdr->iSize ){
20912 randomFill(&((
char*)pNew)[pOldHdr->iSize], nByte - (
int)pOldHdr->iSize);
20914 sqlite3MemFree(pPrior);
20923 SQLITE_PRIVATE
void sqlite3MemSetDefault(
void){
20931 sqlite3MemShutdown,
20934 sqlite3_config(SQLITE_CONFIG_MALLOC, &defaultMethods);
20940 SQLITE_PRIVATE
void sqlite3MemdebugSetType(
void *p, u8 eType){
20941 if( p && sqlite3GlobalConfig.m.xMalloc==sqlite3MemMalloc ){
20942 struct MemBlockHdr *pHdr;
20943 pHdr = sqlite3MemsysGetHeader(p);
20944 assert( pHdr->iForeGuard==FOREGUARD );
20945 pHdr->eType = eType;
20958 SQLITE_PRIVATE
int sqlite3MemdebugHasType(
void *p, u8 eType){
20960 if( p && sqlite3GlobalConfig.m.xMalloc==sqlite3MemMalloc ){
20961 struct MemBlockHdr *pHdr;
20962 pHdr = sqlite3MemsysGetHeader(p);
20963 assert( pHdr->iForeGuard==FOREGUARD );
20964 if( (pHdr->eType&eType)==0 ){
20980 SQLITE_PRIVATE
int sqlite3MemdebugNoType(
void *p, u8 eType){
20982 if( p && sqlite3GlobalConfig.m.xMalloc==sqlite3MemMalloc ){
20983 struct MemBlockHdr *pHdr;
20984 pHdr = sqlite3MemsysGetHeader(p);
20985 assert( pHdr->iForeGuard==FOREGUARD );
20986 if( (pHdr->eType&eType)!=0 ){
20998 SQLITE_PRIVATE
void sqlite3MemdebugBacktrace(
int depth){
20999 if( depth<0 ){ depth = 0; }
21000 if( depth>20 ){ depth = 20; }
21001 depth = (depth+1)&0xfe;
21002 mem.nBacktrace = depth;
21005 SQLITE_PRIVATE
void sqlite3MemdebugBacktraceCallback(
void (*xBacktrace)(
int,
int,
void **)){
21006 mem.xBacktrace = xBacktrace;
21012 SQLITE_PRIVATE
void sqlite3MemdebugSettitle(
const char *zTitle){
21013 unsigned int n = sqlite3Strlen30(zTitle) + 1;
21014 sqlite3_mutex_enter(mem.mutex);
21015 if( n>=
sizeof(mem.zTitle) ) n =
sizeof(mem.zTitle)-1;
21016 memcpy(mem.zTitle, zTitle, n);
21018 mem.nTitle = ROUND8(n);
21019 sqlite3_mutex_leave(mem.mutex);
21022 SQLITE_PRIVATE
void sqlite3MemdebugSync(){
21023 struct MemBlockHdr *pHdr;
21024 for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){
21025 void **pBt = (
void**)pHdr;
21026 pBt -= pHdr->nBacktraceSlots;
21027 mem.xBacktrace((
int)pHdr->iSize, pHdr->nBacktrace-1, &pBt[1]);
21035 SQLITE_PRIVATE
void sqlite3MemdebugDump(
const char *zFilename){
21037 struct MemBlockHdr *pHdr;
21040 out = fopen(zFilename,
"w");
21042 fprintf(stderr,
"** Unable to output memory debug output log: %s **\n",
21046 for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){
21047 char *z = (
char*)pHdr;
21048 z -= pHdr->nBacktraceSlots*
sizeof(
void*) + pHdr->nTitle;
21049 fprintf(out,
"**** %lld bytes at %p from %s ****\n",
21050 pHdr->iSize, &pHdr[1], pHdr->nTitle ? z :
"???");
21051 if( pHdr->nBacktrace ){
21053 pBt = (
void**)pHdr;
21054 pBt -= pHdr->nBacktraceSlots;
21055 backtrace_symbols_fd(pBt, pHdr->nBacktrace, fileno(out));
21056 fprintf(out,
"\n");
21059 fprintf(out,
"COUNTS:\n");
21060 for(i=0; i<NCSIZE-1; i++){
21061 if( mem.nAlloc[i] ){
21062 fprintf(out,
" %5d: %10d %10d %10d\n",
21063 i*8, mem.nAlloc[i], mem.nCurrent[i], mem.mxCurrent[i]);
21066 if( mem.nAlloc[NCSIZE-1] ){
21067 fprintf(out,
" %5d: %10d %10d %10d\n",
21068 NCSIZE*8-8, mem.nAlloc[NCSIZE-1],
21069 mem.nCurrent[NCSIZE-1], mem.mxCurrent[NCSIZE-1]);
21077 SQLITE_PRIVATE
int sqlite3MemdebugMallocCount(){
21080 for(i=0; i<NCSIZE; i++){
21081 nTotal += mem.nAlloc[i];
21125 #ifdef SQLITE_ENABLE_MEMSYS3 21130 #define MX_SMALL 10 21170 typedef struct Mem3Block Mem3Block;
21190 static SQLITE_WSD
struct Mem3Global {
21227 u32 aiSmall[MX_SMALL-1];
21228 u32 aiHash[N_HASH];
21229 } mem3 = { 97535575 };
21231 #define mem3 GLOBAL(struct Mem3Global, mem3) 21237 static void memsys3UnlinkFromList(u32 i, u32 *pRoot){
21238 u32 next = mem3.aPool[i].u.list.next;
21239 u32 prev = mem3.aPool[i].u.list.prev;
21240 assert( sqlite3_mutex_held(mem3.mutex) );
21244 mem3.aPool[prev].u.list.next = next;
21247 mem3.aPool[next].u.list.prev = prev;
21249 mem3.aPool[i].u.list.next = 0;
21250 mem3.aPool[i].u.list.prev = 0;
21257 static void memsys3Unlink(u32 i){
21259 assert( sqlite3_mutex_held(mem3.mutex) );
21260 assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 );
21262 size = mem3.aPool[i-1].u.hdr.size4x/4;
21263 assert( size==mem3.aPool[i+size-1].u.hdr.prevSize );
21265 if( size <= MX_SMALL ){
21266 memsys3UnlinkFromList(i, &mem3.aiSmall[size-2]);
21268 hash = size % N_HASH;
21269 memsys3UnlinkFromList(i, &mem3.aiHash[hash]);
21277 static void memsys3LinkIntoList(u32 i, u32 *pRoot){
21278 assert( sqlite3_mutex_held(mem3.mutex) );
21279 mem3.aPool[i].u.list.next = *pRoot;
21280 mem3.aPool[i].u.list.prev = 0;
21282 mem3.aPool[*pRoot].u.list.prev = i;
21291 static void memsys3Link(u32 i){
21293 assert( sqlite3_mutex_held(mem3.mutex) );
21295 assert( (mem3.aPool[i-1].u.hdr.size4x & 1)==0 );
21296 size = mem3.aPool[i-1].u.hdr.size4x/4;
21297 assert( size==mem3.aPool[i+size-1].u.hdr.prevSize );
21299 if( size <= MX_SMALL ){
21300 memsys3LinkIntoList(i, &mem3.aiSmall[size-2]);
21302 hash = size % N_HASH;
21303 memsys3LinkIntoList(i, &mem3.aiHash[hash]);
21312 static void memsys3Enter(
void){
21313 if( sqlite3GlobalConfig.bMemstat==0 && mem3.mutex==0 ){
21314 mem3.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
21316 sqlite3_mutex_enter(mem3.mutex);
21318 static void memsys3Leave(
void){
21319 sqlite3_mutex_leave(mem3.mutex);
21325 static void memsys3OutOfMemory(
int nByte){
21326 if( !mem3.alarmBusy ){
21327 mem3.alarmBusy = 1;
21328 assert( sqlite3_mutex_held(mem3.mutex) );
21329 sqlite3_mutex_leave(mem3.mutex);
21330 sqlite3_release_memory(nByte);
21331 sqlite3_mutex_enter(mem3.mutex);
21332 mem3.alarmBusy = 0;
21342 static void *memsys3Checkout(u32 i, u32 nBlock){
21344 assert( sqlite3_mutex_held(mem3.mutex) );
21346 assert( mem3.aPool[i-1].u.hdr.size4x/4==nBlock );
21347 assert( mem3.aPool[i+nBlock-1].u.hdr.prevSize==nBlock );
21348 x = mem3.aPool[i-1].u.hdr.size4x;
21349 mem3.aPool[i-1].u.hdr.size4x = nBlock*4 | 1 | (x&2);
21350 mem3.aPool[i+nBlock-1].u.hdr.prevSize = nBlock;
21351 mem3.aPool[i+nBlock-1].u.hdr.size4x |= 2;
21352 return &mem3.aPool[i];
21360 static void *memsys3FromMaster(u32 nBlock){
21361 assert( sqlite3_mutex_held(mem3.mutex) );
21362 assert( mem3.szMaster>=nBlock );
21363 if( nBlock>=mem3.szMaster-1 ){
21365 void *p = memsys3Checkout(mem3.iMaster, mem3.szMaster);
21373 newi = mem3.iMaster + mem3.szMaster - nBlock;
21374 assert( newi > mem3.iMaster+1 );
21375 mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.prevSize = nBlock;
21376 mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.size4x |= 2;
21377 mem3.aPool[newi-1].u.hdr.size4x = nBlock*4 + 1;
21378 mem3.szMaster -= nBlock;
21379 mem3.aPool[newi-1].u.hdr.prevSize = mem3.szMaster;
21380 x = mem3.aPool[mem3.iMaster-1].u.hdr.size4x & 2;
21381 mem3.aPool[mem3.iMaster-1].u.hdr.size4x = mem3.szMaster*4 | x;
21382 if( mem3.szMaster < mem3.mnMaster ){
21383 mem3.mnMaster = mem3.szMaster;
21385 return (
void*)&mem3.aPool[newi];
21405 static void memsys3Merge(u32 *pRoot){
21406 u32 iNext, prev, size, i, x;
21408 assert( sqlite3_mutex_held(mem3.mutex) );
21409 for(i=*pRoot; i>0; i=iNext){
21410 iNext = mem3.aPool[i].u.list.next;
21411 size = mem3.aPool[i-1].u.hdr.size4x;
21412 assert( (size&1)==0 );
21414 memsys3UnlinkFromList(i, pRoot);
21415 assert( i > mem3.aPool[i-1].u.hdr.prevSize );
21416 prev = i - mem3.aPool[i-1].u.hdr.prevSize;
21418 iNext = mem3.aPool[prev].u.list.next;
21420 memsys3Unlink(prev);
21421 size = i + size/4 - prev;
21422 x = mem3.aPool[prev-1].u.hdr.size4x & 2;
21423 mem3.aPool[prev-1].u.hdr.size4x = size*4 | x;
21424 mem3.aPool[prev+size-1].u.hdr.prevSize = size;
21430 if( size>mem3.szMaster ){
21432 mem3.szMaster = size;
21444 static void *memsys3MallocUnsafe(
int nByte){
21449 assert( sqlite3_mutex_held(mem3.mutex) );
21450 assert(
sizeof(Mem3Block)==8 );
21454 nBlock = (nByte + 11)/8;
21456 assert( nBlock>=2 );
21463 if( nBlock <= MX_SMALL ){
21464 i = mem3.aiSmall[nBlock-2];
21466 memsys3UnlinkFromList(i, &mem3.aiSmall[nBlock-2]);
21467 return memsys3Checkout(i, nBlock);
21470 int hash = nBlock % N_HASH;
21471 for(i=mem3.aiHash[hash]; i>0; i=mem3.aPool[i].u.list.next){
21472 if( mem3.aPool[i-1].u.hdr.size4x/4==nBlock ){
21473 memsys3UnlinkFromList(i, &mem3.aiHash[hash]);
21474 return memsys3Checkout(i, nBlock);
21483 if( mem3.szMaster>=nBlock ){
21484 return memsys3FromMaster(nBlock);
21495 for(toFree=nBlock*16; toFree<(mem3.nPool*16); toFree *= 2){
21496 memsys3OutOfMemory(toFree);
21497 if( mem3.iMaster ){
21498 memsys3Link(mem3.iMaster);
21502 for(i=0; i<N_HASH; i++){
21503 memsys3Merge(&mem3.aiHash[i]);
21505 for(i=0; i<MX_SMALL-1; i++){
21506 memsys3Merge(&mem3.aiSmall[i]);
21508 if( mem3.szMaster ){
21509 memsys3Unlink(mem3.iMaster);
21510 if( mem3.szMaster>=nBlock ){
21511 return memsys3FromMaster(nBlock);
21526 static void memsys3FreeUnsafe(
void *pOld){
21527 Mem3Block *p = (Mem3Block*)pOld;
21530 assert( sqlite3_mutex_held(mem3.mutex) );
21531 assert( p>mem3.aPool && p<&mem3.aPool[mem3.nPool] );
21532 i = p - mem3.aPool;
21533 assert( (mem3.aPool[i-1].u.hdr.size4x&1)==1 );
21534 size = mem3.aPool[i-1].u.hdr.size4x/4;
21535 assert( i+size<=mem3.nPool+1 );
21536 mem3.aPool[i-1].u.hdr.size4x &= ~1;
21537 mem3.aPool[i+size-1].u.hdr.prevSize = size;
21538 mem3.aPool[i+size-1].u.hdr.size4x &= ~2;
21542 if( mem3.iMaster ){
21543 while( (mem3.aPool[mem3.iMaster-1].u.hdr.size4x&2)==0 ){
21544 size = mem3.aPool[mem3.iMaster-1].u.hdr.prevSize;
21545 mem3.iMaster -= size;
21546 mem3.szMaster += size;
21547 memsys3Unlink(mem3.iMaster);
21548 x = mem3.aPool[mem3.iMaster-1].u.hdr.size4x & 2;
21549 mem3.aPool[mem3.iMaster-1].u.hdr.size4x = mem3.szMaster*4 | x;
21550 mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.prevSize = mem3.szMaster;
21552 x = mem3.aPool[mem3.iMaster-1].u.hdr.size4x & 2;
21553 while( (mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.size4x&1)==0 ){
21554 memsys3Unlink(mem3.iMaster+mem3.szMaster);
21555 mem3.szMaster += mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.size4x/4;
21556 mem3.aPool[mem3.iMaster-1].u.hdr.size4x = mem3.szMaster*4 | x;
21557 mem3.aPool[mem3.iMaster+mem3.szMaster-1].u.hdr.prevSize = mem3.szMaster;
21567 static int memsys3Size(
void *p){
21570 pBlock = (Mem3Block*)p;
21571 assert( (pBlock[-1].u.hdr.size4x&1)!=0 );
21572 return (pBlock[-1].u.hdr.size4x&~3)*2 - 4;
21578 static int memsys3Roundup(
int n){
21582 return ((n+11)&~7) - 4;
21589 static void *memsys3Malloc(
int nBytes){
21591 assert( nBytes>0 );
21593 p = memsys3MallocUnsafe(nBytes);
21601 static void memsys3Free(
void *pPrior){
21604 memsys3FreeUnsafe(pPrior);
21611 static void *memsys3Realloc(
void *pPrior,
int nBytes){
21615 return sqlite3_malloc(nBytes);
21618 sqlite3_free(pPrior);
21621 nOld = memsys3Size(pPrior);
21622 if( nBytes<=nOld && nBytes>=nOld-128 ){
21626 p = memsys3MallocUnsafe(nBytes);
21629 memcpy(p, pPrior, nOld);
21631 memcpy(p, pPrior, nBytes);
21633 memsys3FreeUnsafe(pPrior);
21642 static int memsys3Init(
void *NotUsed){
21643 UNUSED_PARAMETER(NotUsed);
21644 if( !sqlite3GlobalConfig.pHeap ){
21645 return SQLITE_ERROR;
21649 assert(
sizeof(Mem3Block)==8 );
21650 mem3.aPool = (Mem3Block *)sqlite3GlobalConfig.pHeap;
21651 mem3.nPool = (sqlite3GlobalConfig.nHeap /
sizeof(Mem3Block)) - 2;
21654 mem3.szMaster = mem3.nPool;
21655 mem3.mnMaster = mem3.szMaster;
21657 mem3.aPool[0].u.hdr.size4x = (mem3.szMaster<<2) + 2;
21658 mem3.aPool[mem3.nPool].u.hdr.prevSize = mem3.nPool;
21659 mem3.aPool[mem3.nPool].u.hdr.size4x = 1;
21667 static void memsys3Shutdown(
void *NotUsed){
21668 UNUSED_PARAMETER(NotUsed);
21679 SQLITE_PRIVATE
void sqlite3Memsys3Dump(
const char *zFilename){
21680 #ifdef SQLITE_DEBUG 21684 if( zFilename==0 || zFilename[0]==0 ){
21687 out = fopen(zFilename,
"w");
21689 fprintf(stderr,
"** Unable to output memory debug output log: %s **\n",
21695 fprintf(out,
"CHUNKS:\n");
21696 for(i=1; i<=mem3.nPool; i+=size/4){
21697 size = mem3.aPool[i-1].u.hdr.size4x;
21699 fprintf(out,
"%p size error\n", &mem3.aPool[i]);
21703 if( (size&1)==0 && mem3.aPool[i+size/4-1].u.hdr.prevSize!=size/4 ){
21704 fprintf(out,
"%p tail size does not match\n", &mem3.aPool[i]);
21708 if( ((mem3.aPool[i+size/4-1].u.hdr.size4x&2)>>1)!=(size&1) ){
21709 fprintf(out,
"%p tail checkout bit is incorrect\n", &mem3.aPool[i]);
21714 fprintf(out,
"%p %6d bytes checked out\n", &mem3.aPool[i], (size/4)*8-8);
21716 fprintf(out,
"%p %6d bytes free%s\n", &mem3.aPool[i], (size/4)*8-8,
21717 i==mem3.iMaster ?
" **master**" :
"");
21720 for(i=0; i<MX_SMALL-1; i++){
21721 if( mem3.aiSmall[i]==0 )
continue;
21722 fprintf(out,
"small(%2d):", i);
21723 for(j = mem3.aiSmall[i]; j>0; j=mem3.aPool[j].u.list.next){
21724 fprintf(out,
" %p(%d)", &mem3.aPool[j],
21725 (mem3.aPool[j-1].u.hdr.size4x/4)*8-8);
21727 fprintf(out,
"\n");
21729 for(i=0; i<N_HASH; i++){
21730 if( mem3.aiHash[i]==0 )
continue;
21731 fprintf(out,
"hash(%2d):", i);
21732 for(j = mem3.aiHash[i]; j>0; j=mem3.aPool[j].u.list.next){
21733 fprintf(out,
" %p(%d)", &mem3.aPool[j],
21734 (mem3.aPool[j-1].u.hdr.size4x/4)*8-8);
21736 fprintf(out,
"\n");
21738 fprintf(out,
"master=%d\n", mem3.iMaster);
21739 fprintf(out,
"nowUsed=%d\n", mem3.nPool*8 - mem3.szMaster*8);
21740 fprintf(out,
"mxUsed=%d\n", mem3.nPool*8 - mem3.mnMaster*8);
21741 sqlite3_mutex_leave(mem3.mutex);
21748 UNUSED_PARAMETER(zFilename);
21774 return &mempoolMethods;
21837 #ifdef SQLITE_ENABLE_MEMSYS5 21847 typedef struct Mem5Link Mem5Link;
21863 #define CTRL_LOGSIZE 0x1f 21864 #define CTRL_FREE 0x20 21872 static SQLITE_WSD
struct Mem5Global {
21885 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) 21904 int aiFreelist[LOGMAX+1];
21917 #define mem5 GLOBAL(struct Mem5Global, mem5) 21923 #define MEM5LINK(idx) ((Mem5Link *)(&mem5.zPool[(idx)*mem5.szAtom])) 21929 static void memsys5Unlink(
int i,
int iLogsize){
21931 assert( i>=0 && i<mem5.nBlock );
21932 assert( iLogsize>=0 && iLogsize<=LOGMAX );
21933 assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize );
21935 next = MEM5LINK(i)->next;
21936 prev = MEM5LINK(i)->prev;
21938 mem5.aiFreelist[iLogsize] = next;
21940 MEM5LINK(prev)->next = next;
21943 MEM5LINK(next)->prev = prev;
21951 static void memsys5Link(
int i,
int iLogsize){
21953 assert( sqlite3_mutex_held(mem5.mutex) );
21954 assert( i>=0 && i<mem5.nBlock );
21955 assert( iLogsize>=0 && iLogsize<=LOGMAX );
21956 assert( (mem5.aCtrl[i] & CTRL_LOGSIZE)==iLogsize );
21958 x = MEM5LINK(i)->next = mem5.aiFreelist[iLogsize];
21959 MEM5LINK(i)->prev = -1;
21961 assert( x<mem5.nBlock );
21962 MEM5LINK(x)->prev = i;
21964 mem5.aiFreelist[iLogsize] = i;
21970 static void memsys5Enter(
void){
21971 sqlite3_mutex_enter(mem5.mutex);
21973 static void memsys5Leave(
void){
21974 sqlite3_mutex_leave(mem5.mutex);
21981 static int memsys5Size(
void *p){
21984 i = (int)(((u8 *)p-mem5.zPool)/mem5.szAtom);
21985 assert( i>=0 && i<mem5.nBlock );
21986 iSize = mem5.szAtom * (1 << (mem5.aCtrl[i]&CTRL_LOGSIZE));
22000 static void *memsys5MallocUnsafe(
int nByte){
22010 if( nByte > 0x40000000 )
return 0;
22012 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) 22015 if( (u32)nByte>mem5.maxRequest ){
22016 mem5.maxRequest = nByte;
22022 for(iFullSz=mem5.szAtom,iLogsize=0; iFullSz<nByte; iFullSz*=2,iLogsize++){}
22028 for(iBin=iLogsize; iBin<=LOGMAX && mem5.aiFreelist[iBin]<0; iBin++){}
22030 testcase( sqlite3GlobalConfig.xLog!=0 );
22031 sqlite3_log(SQLITE_NOMEM,
"failed to allocate %u bytes", nByte);
22034 i = mem5.aiFreelist[iBin];
22035 memsys5Unlink(i, iBin);
22036 while( iBin>iLogsize ){
22040 newSize = 1 << iBin;
22041 mem5.aCtrl[i+newSize] = CTRL_FREE | iBin;
22042 memsys5Link(i+newSize, iBin);
22044 mem5.aCtrl[i] = iLogsize;
22046 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) 22049 mem5.totalAlloc += iFullSz;
22050 mem5.totalExcess += iFullSz - nByte;
22051 mem5.currentCount++;
22052 mem5.currentOut += iFullSz;
22053 if( mem5.maxCount<mem5.currentCount ) mem5.maxCount = mem5.currentCount;
22054 if( mem5.maxOut<mem5.currentOut ) mem5.maxOut = mem5.currentOut;
22057 #ifdef SQLITE_DEBUG 22060 memset(&mem5.zPool[i*mem5.szAtom], 0xAA, iFullSz);
22064 return (
void*)&mem5.zPool[i*mem5.szAtom];
22070 static void memsys5FreeUnsafe(
void *pOld){
22071 u32 size, iLogsize;
22077 iBlock = (int)(((u8 *)pOld-mem5.zPool)/mem5.szAtom);
22080 assert( iBlock>=0 && iBlock<mem5.nBlock );
22081 assert( ((u8 *)pOld-mem5.zPool)%mem5.szAtom==0 );
22082 assert( (mem5.aCtrl[iBlock] & CTRL_FREE)==0 );
22084 iLogsize = mem5.aCtrl[iBlock] & CTRL_LOGSIZE;
22085 size = 1<<iLogsize;
22086 assert( iBlock+size-1<(u32)mem5.nBlock );
22088 mem5.aCtrl[iBlock] |= CTRL_FREE;
22089 mem5.aCtrl[iBlock+size-1] |= CTRL_FREE;
22091 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) 22092 assert( mem5.currentCount>0 );
22093 assert( mem5.currentOut>=(size*mem5.szAtom) );
22094 mem5.currentCount--;
22095 mem5.currentOut -= size*mem5.szAtom;
22096 assert( mem5.currentOut>0 || mem5.currentCount==0 );
22097 assert( mem5.currentCount>0 || mem5.currentOut==0 );
22100 mem5.aCtrl[iBlock] = CTRL_FREE | iLogsize;
22101 while( ALWAYS(iLogsize<LOGMAX) ){
22103 if( (iBlock>>iLogsize) & 1 ){
22104 iBuddy = iBlock - size;
22105 assert( iBuddy>=0 );
22107 iBuddy = iBlock + size;
22108 if( iBuddy>=mem5.nBlock )
break;
22110 if( mem5.aCtrl[iBuddy]!=(CTRL_FREE | iLogsize) )
break;
22111 memsys5Unlink(iBuddy, iLogsize);
22113 if( iBuddy<iBlock ){
22114 mem5.aCtrl[iBuddy] = CTRL_FREE | iLogsize;
22115 mem5.aCtrl[iBlock] = 0;
22118 mem5.aCtrl[iBlock] = CTRL_FREE | iLogsize;
22119 mem5.aCtrl[iBuddy] = 0;
22124 #ifdef SQLITE_DEBUG 22127 memset(&mem5.zPool[iBlock*mem5.szAtom], 0x55, size);
22130 memsys5Link(iBlock, iLogsize);
22136 static void *memsys5Malloc(
int nBytes){
22137 sqlite3_int64 *p = 0;
22140 p = memsys5MallocUnsafe(nBytes);
22152 static void memsys5Free(
void *pPrior){
22153 assert( pPrior!=0 );
22155 memsys5FreeUnsafe(pPrior);
22171 static void *memsys5Realloc(
void *pPrior,
int nBytes){
22174 assert( pPrior!=0 );
22175 assert( (nBytes&(nBytes-1))==0 );
22176 assert( nBytes>=0 );
22180 nOld = memsys5Size(pPrior);
22181 if( nBytes<=nOld ){
22184 p = memsys5Malloc(nBytes);
22186 memcpy(p, pPrior, nOld);
22187 memsys5Free(pPrior);
22201 static int memsys5Roundup(
int n){
22203 if( n > 0x40000000 )
return 0;
22204 for(iFullSz=mem5.szAtom; iFullSz<n; iFullSz *= 2);
22218 static int memsys5Log(
int iValue){
22220 for(iLog=0; (iLog<(int)((
sizeof(
int)*8)-1)) && (1<<iLog)<iValue; iLog++);
22230 static int memsys5Init(
void *NotUsed){
22237 UNUSED_PARAMETER(NotUsed);
22245 assert( (
sizeof(Mem5Link)&(
sizeof(Mem5Link)-1))==0 );
22247 nByte = sqlite3GlobalConfig.nHeap;
22248 zByte = (u8*)sqlite3GlobalConfig.pHeap;
22249 assert( zByte!=0 );
22252 nMinLog = memsys5Log(sqlite3GlobalConfig.mnReq);
22253 mem5.szAtom = (1<<nMinLog);
22254 while( (
int)
sizeof(Mem5Link)>mem5.szAtom ){
22255 mem5.szAtom = mem5.szAtom << 1;
22258 mem5.nBlock = (nByte / (mem5.szAtom+
sizeof(u8)));
22259 mem5.zPool = zByte;
22260 mem5.aCtrl = (u8 *)&mem5.zPool[mem5.nBlock*mem5.szAtom];
22262 for(ii=0; ii<=LOGMAX; ii++){
22263 mem5.aiFreelist[ii] = -1;
22267 for(ii=LOGMAX; ii>=0; ii--){
22268 int nAlloc = (1<<ii);
22269 if( (iOffset+nAlloc)<=mem5.nBlock ){
22270 mem5.aCtrl[iOffset] = ii | CTRL_FREE;
22271 memsys5Link(iOffset, ii);
22274 assert((iOffset+nAlloc)>mem5.nBlock);
22278 if( sqlite3GlobalConfig.bMemstat==0 ){
22279 mem5.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
22288 static void memsys5Shutdown(
void *NotUsed){
22289 UNUSED_PARAMETER(NotUsed);
22299 SQLITE_PRIVATE
void sqlite3Memsys5Dump(
const char *zFilename){
22304 if( zFilename==0 || zFilename[0]==0 ){
22307 out = fopen(zFilename,
"w");
22309 fprintf(stderr,
"** Unable to output memory debug output log: %s **\n",
22315 nMinLog = memsys5Log(mem5.szAtom);
22316 for(i=0; i<=LOGMAX && i+nMinLog<32; i++){
22317 for(n=0, j=mem5.aiFreelist[i]; j>=0; j = MEM5LINK(j)->next, n++){}
22318 fprintf(out,
"freelist items of size %d: %d\n", mem5.szAtom << i, n);
22320 fprintf(out,
"mem5.nAlloc = %llu\n", mem5.nAlloc);
22321 fprintf(out,
"mem5.totalAlloc = %llu\n", mem5.totalAlloc);
22322 fprintf(out,
"mem5.totalExcess = %llu\n", mem5.totalExcess);
22323 fprintf(out,
"mem5.currentOut = %u\n", mem5.currentOut);
22324 fprintf(out,
"mem5.currentCount = %u\n", mem5.currentCount);
22325 fprintf(out,
"mem5.maxOut = %u\n", mem5.maxOut);
22326 fprintf(out,
"mem5.maxCount = %u\n", mem5.maxCount);
22327 fprintf(out,
"mem5.maxRequest = %u\n", mem5.maxRequest);
22353 return &memsys5Methods;
22377 #if defined(SQLITE_DEBUG) && !defined(SQLITE_MUTEX_OMIT) 22383 static SQLITE_WSD
int mutexIsInit = 0;
22387 #ifndef SQLITE_MUTEX_OMIT 22391 SQLITE_PRIVATE
int sqlite3MutexInit(
void){
22392 int rc = SQLITE_OK;
22393 if( !sqlite3GlobalConfig.mutex.xMutexAlloc ){
22402 if( sqlite3GlobalConfig.bCoreMutex ){
22403 pFrom = sqlite3DefaultMutex();
22405 pFrom = sqlite3NoopMutex();
22407 pTo->xMutexInit = pFrom->xMutexInit;
22408 pTo->xMutexEnd = pFrom->xMutexEnd;
22409 pTo->xMutexFree = pFrom->xMutexFree;
22410 pTo->xMutexEnter = pFrom->xMutexEnter;
22411 pTo->xMutexTry = pFrom->xMutexTry;
22412 pTo->xMutexLeave = pFrom->xMutexLeave;
22413 pTo->xMutexHeld = pFrom->xMutexHeld;
22414 pTo->xMutexNotheld = pFrom->xMutexNotheld;
22415 sqlite3MemoryBarrier();
22416 pTo->xMutexAlloc = pFrom->xMutexAlloc;
22418 assert( sqlite3GlobalConfig.mutex.xMutexInit );
22419 rc = sqlite3GlobalConfig.mutex.xMutexInit();
22421 #ifdef SQLITE_DEBUG 22422 GLOBAL(
int, mutexIsInit) = 1;
22432 SQLITE_PRIVATE
int sqlite3MutexEnd(
void){
22433 int rc = SQLITE_OK;
22434 if( sqlite3GlobalConfig.mutex.xMutexEnd ){
22435 rc = sqlite3GlobalConfig.mutex.xMutexEnd();
22438 #ifdef SQLITE_DEBUG 22439 GLOBAL(
int, mutexIsInit) = 0;
22448 SQLITE_API
sqlite3_mutex *SQLITE_STDCALL sqlite3_mutex_alloc(
int id){
22449 #ifndef SQLITE_OMIT_AUTOINIT 22450 if(
id<=SQLITE_MUTEX_RECURSIVE && sqlite3_initialize() )
return 0;
22451 if(
id>SQLITE_MUTEX_RECURSIVE && sqlite3MutexInit() )
return 0;
22453 assert( sqlite3GlobalConfig.mutex.xMutexAlloc );
22454 return sqlite3GlobalConfig.mutex.xMutexAlloc(
id);
22458 if( !sqlite3GlobalConfig.bCoreMutex ){
22461 assert( GLOBAL(
int, mutexIsInit) );
22462 assert( sqlite3GlobalConfig.mutex.xMutexAlloc );
22463 return sqlite3GlobalConfig.mutex.xMutexAlloc(
id);
22469 SQLITE_API
void SQLITE_STDCALL sqlite3_mutex_free(
sqlite3_mutex *p){
22471 assert( sqlite3GlobalConfig.mutex.xMutexFree );
22472 sqlite3GlobalConfig.mutex.xMutexFree(p);
22480 SQLITE_API
void SQLITE_STDCALL sqlite3_mutex_enter(
sqlite3_mutex *p){
22482 assert( sqlite3GlobalConfig.mutex.xMutexEnter );
22483 sqlite3GlobalConfig.mutex.xMutexEnter(p);
22491 SQLITE_API
int SQLITE_STDCALL sqlite3_mutex_try(
sqlite3_mutex *p){
22492 int rc = SQLITE_OK;
22494 assert( sqlite3GlobalConfig.mutex.xMutexTry );
22495 return sqlite3GlobalConfig.mutex.xMutexTry(p);
22506 SQLITE_API
void SQLITE_STDCALL sqlite3_mutex_leave(
sqlite3_mutex *p){
22508 assert( sqlite3GlobalConfig.mutex.xMutexLeave );
22509 sqlite3GlobalConfig.mutex.xMutexLeave(p);
22518 SQLITE_API
int SQLITE_STDCALL sqlite3_mutex_held(
sqlite3_mutex *p){
22519 assert( p==0 || sqlite3GlobalConfig.mutex.xMutexHeld );
22520 return p==0 || sqlite3GlobalConfig.mutex.xMutexHeld(p);
22522 SQLITE_API
int SQLITE_STDCALL sqlite3_mutex_notheld(
sqlite3_mutex *p){
22523 assert( p==0 || sqlite3GlobalConfig.mutex.xMutexNotheld );
22524 return p==0 || sqlite3GlobalConfig.mutex.xMutexNotheld(p);
22561 #ifndef SQLITE_MUTEX_OMIT 22563 #ifndef SQLITE_DEBUG 22569 static int noopMutexInit(
void){
return SQLITE_OK; }
22570 static int noopMutexEnd(
void){
return SQLITE_OK; }
22572 UNUSED_PARAMETER(
id);
22575 static void noopMutexFree(
sqlite3_mutex *p){ UNUSED_PARAMETER(p);
return; }
22576 static void noopMutexEnter(
sqlite3_mutex *p){ UNUSED_PARAMETER(p);
return; }
22578 UNUSED_PARAMETER(p);
22581 static void noopMutexLeave(
sqlite3_mutex *p){ UNUSED_PARAMETER(p);
return; }
22601 #ifdef SQLITE_DEBUG 22611 typedef struct sqlite3_debug_mutex {
22614 } sqlite3_debug_mutex;
22621 sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
22622 return p==0 || p->cnt>0;
22625 sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
22626 return p==0 || p->cnt==0;
22632 static int debugMutexInit(
void){
return SQLITE_OK; }
22633 static int debugMutexEnd(
void){
return SQLITE_OK; }
22641 static sqlite3_debug_mutex aStatic[SQLITE_MUTEX_STATIC_VFS3 - 1];
22642 sqlite3_debug_mutex *pNew = 0;
22644 case SQLITE_MUTEX_FAST:
22645 case SQLITE_MUTEX_RECURSIVE: {
22646 pNew = sqlite3Malloc(
sizeof(*pNew));
22654 #ifdef SQLITE_ENABLE_API_ARMOR 22655 if(
id-2<0 ||
id-2>=ArraySize(aStatic) ){
22656 (void)SQLITE_MISUSE_BKPT;
22660 pNew = &aStatic[
id-2];
22672 sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
22673 assert( p->cnt==0 );
22674 if( p->id==SQLITE_MUTEX_RECURSIVE || p->id==SQLITE_MUTEX_FAST ){
22677 #ifdef SQLITE_ENABLE_API_ARMOR 22678 (void)SQLITE_MISUSE_BKPT;
22695 sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
22696 assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) );
22700 sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
22701 assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) );
22713 sqlite3_debug_mutex *p = (sqlite3_debug_mutex*)pX;
22714 assert( debugMutexHeld(pX) );
22716 assert( p->id==SQLITE_MUTEX_RECURSIVE || debugMutexNotheld(pX) );
22741 #ifdef SQLITE_MUTEX_NOOP 22743 return sqlite3NoopMutex();
22772 #ifdef SQLITE_MUTEX_PTHREADS 22774 #include <pthread.h> 22781 #if defined(SQLITE_DEBUG) || defined(SQLITE_HOMEGROWN_RECURSIVE_MUTEX) 22782 # define SQLITE_MUTEX_NREF 1 22784 # define SQLITE_MUTEX_NREF 0 22791 pthread_mutex_t mutex;
22792 #if SQLITE_MUTEX_NREF || defined(SQLITE_ENABLE_API_ARMOR) 22795 #if SQLITE_MUTEX_NREF 22797 volatile pthread_t owner;
22801 #if SQLITE_MUTEX_NREF 22802 #define SQLITE3_MUTEX_INITIALIZER {PTHREAD_MUTEX_INITIALIZER,0,0,(pthread_t)0,0} 22803 #elif defined(SQLITE_ENABLE_API_ARMOR) 22804 #define SQLITE3_MUTEX_INITIALIZER { PTHREAD_MUTEX_INITIALIZER, 0 } 22806 #define SQLITE3_MUTEX_INITIALIZER { PTHREAD_MUTEX_INITIALIZER } 22825 #if !defined(NDEBUG) || defined(SQLITE_DEBUG) 22827 return (p->nRef!=0 && pthread_equal(p->owner, pthread_self()));
22830 return p->nRef==0 || pthread_equal(p->owner, pthread_self())==0;
22839 SQLITE_PRIVATE
void sqlite3MemoryBarrier(
void){
22840 #if defined(SQLITE_MEMORY_BARRIER) 22841 SQLITE_MEMORY_BARRIER;
22842 #elif defined(__GNUC__) && GCC_VERSION>=4001000 22843 __sync_synchronize();
22850 static int pthreadMutexInit(
void){
return SQLITE_OK; }
22851 static int pthreadMutexEnd(
void){
return SQLITE_OK; }
22903 SQLITE3_MUTEX_INITIALIZER,
22904 SQLITE3_MUTEX_INITIALIZER,
22905 SQLITE3_MUTEX_INITIALIZER,
22906 SQLITE3_MUTEX_INITIALIZER,
22907 SQLITE3_MUTEX_INITIALIZER,
22908 SQLITE3_MUTEX_INITIALIZER,
22909 SQLITE3_MUTEX_INITIALIZER,
22910 SQLITE3_MUTEX_INITIALIZER,
22911 SQLITE3_MUTEX_INITIALIZER,
22912 SQLITE3_MUTEX_INITIALIZER,
22913 SQLITE3_MUTEX_INITIALIZER,
22914 SQLITE3_MUTEX_INITIALIZER
22918 case SQLITE_MUTEX_RECURSIVE: {
22919 p = sqlite3MallocZero(
sizeof(*p) );
22921 #ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX 22924 pthread_mutex_init(&p->mutex, 0);
22927 pthread_mutexattr_t recursiveAttr;
22928 pthread_mutexattr_init(&recursiveAttr);
22929 pthread_mutexattr_settype(&recursiveAttr, PTHREAD_MUTEX_RECURSIVE);
22930 pthread_mutex_init(&p->mutex, &recursiveAttr);
22931 pthread_mutexattr_destroy(&recursiveAttr);
22936 case SQLITE_MUTEX_FAST: {
22937 p = sqlite3MallocZero(
sizeof(*p) );
22939 pthread_mutex_init(&p->mutex, 0);
22944 #ifdef SQLITE_ENABLE_API_ARMOR 22945 if( iType-2<0 || iType-2>=ArraySize(staticMutexes) ){
22946 (void)SQLITE_MISUSE_BKPT;
22950 p = &staticMutexes[iType-2];
22954 #if SQLITE_MUTEX_NREF || defined(SQLITE_ENABLE_API_ARMOR) 22955 if( p ) p->id = iType;
22967 assert( p->nRef==0 );
22968 #if SQLITE_ENABLE_API_ARMOR 22969 if( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE )
22972 pthread_mutex_destroy(&p->mutex);
22975 #ifdef SQLITE_ENABLE_API_ARMOR 22977 (void)SQLITE_MISUSE_BKPT;
22994 assert( p->id==SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p) );
22996 #ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX 23008 pthread_t
self = pthread_self();
23009 if( p->nRef>0 && pthread_equal(p->owner,
self) ){
23012 pthread_mutex_lock(&p->mutex);
23013 assert( p->nRef==0 );
23021 pthread_mutex_lock(&p->mutex);
23022 #if SQLITE_MUTEX_NREF 23023 assert( p->nRef>0 || p->owner==0 );
23024 p->owner = pthread_self();
23029 #ifdef SQLITE_DEBUG 23031 printf(
"enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
23037 assert( p->id==SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p) );
23039 #ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX 23051 pthread_t
self = pthread_self();
23052 if( p->nRef>0 && pthread_equal(p->owner,
self) ){
23055 }
else if( pthread_mutex_trylock(&p->mutex)==0 ){
23056 assert( p->nRef==0 );
23067 if( pthread_mutex_trylock(&p->mutex)==0 ){
23068 #if SQLITE_MUTEX_NREF 23069 p->owner = pthread_self();
23078 #ifdef SQLITE_DEBUG 23079 if( rc==SQLITE_OK && p->trace ){
23080 printf(
"enter mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
23093 assert( pthreadMutexHeld(p) );
23094 #if SQLITE_MUTEX_NREF 23096 if( p->nRef==0 ) p->owner = 0;
23098 assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE );
23100 #ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX 23102 pthread_mutex_unlock(&p->mutex);
23105 pthread_mutex_unlock(&p->mutex);
23108 #ifdef SQLITE_DEBUG 23110 printf(
"leave mutex %p (%d) with nRef=%d\n", p, p->trace, p->nRef);
23124 #ifdef SQLITE_DEBUG 23126 pthreadMutexNotheld
23180 #ifndef _OS_COMMON_H_ 23181 #define _OS_COMMON_H_ 23188 #ifdef MEMORY_DEBUG 23189 # error "The MEMORY_DEBUG macro is obsolete. Use SQLITE_DEBUG instead." 23196 #ifdef SQLITE_PERFORMANCE_TRACE 23219 #ifndef SQLITE_HWTIME_H 23220 #define SQLITE_HWTIME_H 23228 #if (defined(__GNUC__) || defined(_MSC_VER)) && \ 23229 (defined(i386) || defined(__i386__) || defined(_M_IX86)) 23231 #if defined(__GNUC__) 23233 __inline__ sqlite_uint64 sqlite3Hwtime(
void){
23234 unsigned int lo, hi;
23235 __asm__ __volatile__ (
"rdtsc" :
"=a" (lo),
"=d" (hi));
23236 return (sqlite_uint64)hi << 32 | lo;
23239 #elif defined(_MSC_VER) 23241 __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(
void){
23244 ret ;
return value at EDX:EAX
23250 #elif (defined(__GNUC__) && defined(__x86_64__)) 23252 __inline__ sqlite_uint64 sqlite3Hwtime(
void){
23254 __asm__ __volatile__ (
"rdtsc" :
"=A" (val));
23258 #elif (defined(__GNUC__) && defined(__ppc__)) 23260 __inline__ sqlite_uint64 sqlite3Hwtime(
void){
23261 unsigned long long retval;
23262 unsigned long junk;
23263 __asm__ __volatile__ (
"\n\ 23269 :
"=r" (retval),
"=r" (junk));
23275 #error Need implementation of sqlite3Hwtime() for your platform. 23284 SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(
void){
return ((sqlite_uint64)0); }
23293 static sqlite_uint64 g_start;
23294 static sqlite_uint64 g_elapsed;
23295 #define TIMER_START g_start=sqlite3Hwtime() 23296 #define TIMER_END g_elapsed=sqlite3Hwtime()-g_start 23297 #define TIMER_ELAPSED g_elapsed 23299 #define TIMER_START 23301 #define TIMER_ELAPSED ((sqlite_uint64)0) 23309 #if defined(SQLITE_TEST) 23310 SQLITE_API
extern int sqlite3_io_error_hit;
23311 SQLITE_API
extern int sqlite3_io_error_hardhit;
23312 SQLITE_API
extern int sqlite3_io_error_pending;
23313 SQLITE_API
extern int sqlite3_io_error_persist;
23314 SQLITE_API
extern int sqlite3_io_error_benign;
23315 SQLITE_API
extern int sqlite3_diskfull_pending;
23316 SQLITE_API
extern int sqlite3_diskfull;
23317 #define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X) 23318 #define SimulateIOError(CODE) \ 23319 if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \ 23320 || sqlite3_io_error_pending-- == 1 ) \ 23321 { local_ioerr(); CODE; } 23322 static void local_ioerr(){
23323 IOTRACE((
"IOERR\n"));
23324 sqlite3_io_error_hit++;
23325 if( !sqlite3_io_error_benign ) sqlite3_io_error_hardhit++;
23327 #define SimulateDiskfullError(CODE) \ 23328 if( sqlite3_diskfull_pending ){ \ 23329 if( sqlite3_diskfull_pending == 1 ){ \ 23331 sqlite3_diskfull = 1; \ 23332 sqlite3_io_error_hit = 1; \ 23335 sqlite3_diskfull_pending--; \ 23339 #define SimulateIOErrorBenign(X) 23340 #define SimulateIOError(A) 23341 #define SimulateDiskfullError(A) 23347 #if defined(SQLITE_TEST) 23348 SQLITE_API
extern int sqlite3_open_file_count;
23349 #define OpenCounter(X) sqlite3_open_file_count+=(X) 23351 #define OpenCounter(X) 23378 #ifndef SQLITE_OS_WIN_H 23379 #define SQLITE_OS_WIN_H 23384 #include "windows.h" 23387 # include <sys/cygwin.h> 23388 # include <errno.h> 23408 #if SQLITE_OS_WIN && !defined(SQLITE_OS_WINNT) 23409 # define SQLITE_OS_WINNT 1 23416 #if defined(_WIN32_WCE) 23417 # define SQLITE_OS_WINCE 1 23419 # define SQLITE_OS_WINCE 0 23426 #if !defined(SQLITE_OS_WINRT) 23427 # define SQLITE_OS_WINRT 0 23434 #if SQLITE_OS_WINCE 23435 # define SQLITE_WIN32_VOLATILE 23437 # define SQLITE_WIN32_VOLATILE volatile 23444 #if SQLITE_OS_WIN && !SQLITE_OS_WINCE && !SQLITE_OS_WINRT && \ 23445 SQLITE_THREADSAFE>0 && !defined(__CYGWIN__) 23446 # define SQLITE_OS_WIN_THREADS 1 23448 # define SQLITE_OS_WIN_THREADS 0 23461 #ifdef SQLITE_MUTEX_W32 23467 CRITICAL_SECTION mutex;
23469 #ifdef SQLITE_DEBUG 23471 volatile DWORD owner;
23472 volatile int trace;
23481 #define SQLITE_W32_MUTEX_INITIALIZER { 0 } 23483 #ifdef SQLITE_DEBUG 23484 #define SQLITE3_MUTEX_INITIALIZER { SQLITE_W32_MUTEX_INITIALIZER, 0, \ 23487 #define SQLITE3_MUTEX_INITIALIZER { SQLITE_W32_MUTEX_INITIALIZER, 0 } 23490 #ifdef SQLITE_DEBUG 23496 return p->nRef!=0 && p->owner==GetCurrentThreadId();
23500 return p->nRef==0 || p->owner!=tid;
23504 DWORD tid = GetCurrentThreadId();
23505 return winMutexNotheld2(p, tid);
23514 SQLITE_PRIVATE
void sqlite3MemoryBarrier(
void){
23515 #if defined(SQLITE_MEMORY_BARRIER) 23516 SQLITE_MEMORY_BARRIER;
23517 #elif defined(__GNUC__) 23518 __sync_synchronize();
23519 #elif !defined(SQLITE_DISABLE_INTRINSIC) && \ 23520 defined(_MSC_VER) && _MSC_VER>=1300 23521 _ReadWriteBarrier();
23522 #elif defined(MemoryBarrier) 23531 SQLITE3_MUTEX_INITIALIZER,
23532 SQLITE3_MUTEX_INITIALIZER,
23533 SQLITE3_MUTEX_INITIALIZER,
23534 SQLITE3_MUTEX_INITIALIZER,
23535 SQLITE3_MUTEX_INITIALIZER,
23536 SQLITE3_MUTEX_INITIALIZER,
23537 SQLITE3_MUTEX_INITIALIZER,
23538 SQLITE3_MUTEX_INITIALIZER,
23539 SQLITE3_MUTEX_INITIALIZER,
23540 SQLITE3_MUTEX_INITIALIZER,
23541 SQLITE3_MUTEX_INITIALIZER,
23542 SQLITE3_MUTEX_INITIALIZER
23545 static int winMutex_isInit = 0;
23546 static int winMutex_isNt = -1;
23552 static LONG SQLITE_WIN32_VOLATILE winMutex_lock = 0;
23554 SQLITE_API
int SQLITE_STDCALL sqlite3_win32_is_nt(
void);
23555 SQLITE_API
void SQLITE_STDCALL sqlite3_win32_sleep(DWORD milliseconds);
23557 static int winMutexInit(
void){
23559 if( InterlockedCompareExchange(&winMutex_lock, 1, 0)==0 ){
23561 for(i=0; i<ArraySize(winMutex_staticMutexes); i++){
23562 #if SQLITE_OS_WINRT 23563 InitializeCriticalSectionEx(&winMutex_staticMutexes[i].mutex, 0, 0);
23565 InitializeCriticalSection(&winMutex_staticMutexes[i].mutex);
23568 winMutex_isInit = 1;
23572 while( !winMutex_isInit ){
23573 sqlite3_win32_sleep(1);
23579 static int winMutexEnd(
void){
23582 if( InterlockedCompareExchange(&winMutex_lock, 0, 1)==1 ){
23583 if( winMutex_isInit==1 ){
23585 for(i=0; i<ArraySize(winMutex_staticMutexes); i++){
23586 DeleteCriticalSection(&winMutex_staticMutexes[i].mutex);
23588 winMutex_isInit = 0;
23646 case SQLITE_MUTEX_FAST:
23647 case SQLITE_MUTEX_RECURSIVE: {
23648 p = sqlite3MallocZero(
sizeof(*p) );
23651 #ifdef SQLITE_DEBUG 23652 #ifdef SQLITE_WIN32_MUTEX_TRACE_DYNAMIC 23656 #if SQLITE_OS_WINRT 23657 InitializeCriticalSectionEx(&p->mutex, 0, 0);
23659 InitializeCriticalSection(&p->mutex);
23665 #ifdef SQLITE_ENABLE_API_ARMOR 23666 if( iType-2<0 || iType-2>=ArraySize(winMutex_staticMutexes) ){
23667 (void)SQLITE_MISUSE_BKPT;
23671 p = &winMutex_staticMutexes[iType-2];
23673 #ifdef SQLITE_DEBUG 23674 #ifdef SQLITE_WIN32_MUTEX_TRACE_STATIC 23692 assert( p->nRef==0 && p->owner==0 );
23693 if( p->id==SQLITE_MUTEX_FAST || p->id==SQLITE_MUTEX_RECURSIVE ){
23694 DeleteCriticalSection(&p->mutex);
23697 #ifdef SQLITE_ENABLE_API_ARMOR 23698 (void)SQLITE_MISUSE_BKPT;
23715 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) 23716 DWORD tid = GetCurrentThreadId();
23718 #ifdef SQLITE_DEBUG 23720 assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) );
23724 assert( winMutex_isInit==1 );
23725 EnterCriticalSection(&p->mutex);
23726 #ifdef SQLITE_DEBUG 23727 assert( p->nRef>0 || p->owner==0 );
23731 OSTRACE((
"ENTER-MUTEX tid=%lu, mutex=%p (%d), nRef=%d\n",
23732 tid, p, p->trace, p->nRef));
23738 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) 23739 DWORD tid = GetCurrentThreadId();
23741 int rc = SQLITE_BUSY;
23743 assert( p->id==SQLITE_MUTEX_RECURSIVE || winMutexNotheld2(p, tid) );
23755 #if defined(_WIN32_WINNT) && _WIN32_WINNT >= 0x0400 23756 assert( winMutex_isInit==1 );
23757 assert( winMutex_isNt>=-1 && winMutex_isNt<=1 );
23758 if( winMutex_isNt<0 ){
23759 winMutex_isNt = sqlite3_win32_is_nt();
23761 assert( winMutex_isNt==0 || winMutex_isNt==1 );
23762 if( winMutex_isNt && TryEnterCriticalSection(&p->mutex) ){
23763 #ifdef SQLITE_DEBUG 23770 UNUSED_PARAMETER(p);
23772 #ifdef SQLITE_DEBUG 23774 OSTRACE((
"TRY-MUTEX tid=%lu, mutex=%p (%d), owner=%lu, nRef=%d, rc=%s\n",
23775 tid, p, p->trace, p->owner, p->nRef, sqlite3ErrName(rc)));
23788 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) 23789 DWORD tid = GetCurrentThreadId();
23792 #ifdef SQLITE_DEBUG 23793 assert( p->nRef>0 );
23794 assert( p->owner==tid );
23796 if( p->nRef==0 ) p->owner = 0;
23797 assert( p->nRef==0 || p->id==SQLITE_MUTEX_RECURSIVE );
23799 assert( winMutex_isInit==1 );
23800 LeaveCriticalSection(&p->mutex);
23801 #ifdef SQLITE_DEBUG 23803 OSTRACE((
"LEAVE-MUTEX tid=%lu, mutex=%p (%d), nRef=%d\n",
23804 tid, p, p->trace, p->nRef));
23818 #ifdef SQLITE_DEBUG 23855 SQLITE_API
int SQLITE_STDCALL sqlite3_release_memory(
int n){
23856 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT 23857 return sqlite3PcacheReleaseMemory(n);
23862 UNUSED_PARAMETER(n);
23878 static SQLITE_WSD
struct Mem0Global {
23880 sqlite3_int64 alarmThreshold;
23897 } mem0 = { 0, 0, 0, 0, 0, 0 };
23899 #define mem0 GLOBAL(struct Mem0Global, mem0) 23908 #ifndef SQLITE_OMIT_DEPRECATED 23914 SQLITE_API
int SQLITE_STDCALL sqlite3_memory_alarm(
23915 void(*xCallback)(
void *pArg, sqlite3_int64 used,
int N),
23917 sqlite3_int64 iThreshold
23930 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_soft_heap_limit64(sqlite3_int64 n){
23931 sqlite3_int64 priorLimit;
23932 sqlite3_int64 excess;
23933 sqlite3_int64 nUsed;
23934 #ifndef SQLITE_OMIT_AUTOINIT 23935 int rc = sqlite3_initialize();
23936 if( rc )
return -1;
23938 sqlite3_mutex_enter(mem0.mutex);
23939 priorLimit = mem0.alarmThreshold;
23941 sqlite3_mutex_leave(mem0.mutex);
23944 mem0.alarmThreshold = n;
23945 nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
23946 mem0.nearlyFull = (n>0 && n<=nUsed);
23947 sqlite3_mutex_leave(mem0.mutex);
23948 excess = sqlite3_memory_used() - n;
23949 if( excess>0 ) sqlite3_release_memory((
int)(excess & 0x7fffffff));
23952 SQLITE_API
void SQLITE_STDCALL sqlite3_soft_heap_limit(
int n){
23954 sqlite3_soft_heap_limit64(n);
23960 SQLITE_PRIVATE
int sqlite3MallocInit(
void){
23962 if( sqlite3GlobalConfig.m.xMalloc==0 ){
23963 sqlite3MemSetDefault();
23965 memset(&mem0, 0,
sizeof(mem0));
23966 mem0.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
23967 if( sqlite3GlobalConfig.pScratch && sqlite3GlobalConfig.szScratch>=100
23968 && sqlite3GlobalConfig.nScratch>0 ){
23971 sz = ROUNDDOWN8(sqlite3GlobalConfig.szScratch);
23972 sqlite3GlobalConfig.szScratch = sz;
23974 n = sqlite3GlobalConfig.nScratch;
23975 mem0.pScratchFree = pSlot;
23976 mem0.nScratchFree = n;
23977 for(i=0; i<n-1; i++){
23979 pSlot = pSlot->pNext;
23982 mem0.pScratchEnd = (
void*)&pSlot[1];
23984 mem0.pScratchEnd = 0;
23985 sqlite3GlobalConfig.pScratch = 0;
23986 sqlite3GlobalConfig.szScratch = 0;
23987 sqlite3GlobalConfig.nScratch = 0;
23989 if( sqlite3GlobalConfig.pPage==0 || sqlite3GlobalConfig.szPage<512
23990 || sqlite3GlobalConfig.nPage<=0 ){
23991 sqlite3GlobalConfig.pPage = 0;
23992 sqlite3GlobalConfig.szPage = 0;
23994 rc = sqlite3GlobalConfig.m.xInit(sqlite3GlobalConfig.m.pAppData);
23995 if( rc!=SQLITE_OK ) memset(&mem0, 0,
sizeof(mem0));
24004 SQLITE_PRIVATE
int sqlite3HeapNearlyFull(
void){
24005 return mem0.nearlyFull;
24011 SQLITE_PRIVATE
void sqlite3MallocEnd(
void){
24012 if( sqlite3GlobalConfig.m.xShutdown ){
24013 sqlite3GlobalConfig.m.xShutdown(sqlite3GlobalConfig.m.pAppData);
24015 memset(&mem0, 0,
sizeof(mem0));
24021 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_memory_used(
void){
24022 sqlite3_int64 res, mx;
24023 sqlite3_status64(SQLITE_STATUS_MEMORY_USED, &res, &mx, 0);
24032 SQLITE_API sqlite3_int64 SQLITE_STDCALL sqlite3_memory_highwater(
int resetFlag){
24033 sqlite3_int64 res, mx;
24034 sqlite3_status64(SQLITE_STATUS_MEMORY_USED, &res, &mx, resetFlag);
24041 static void sqlite3MallocAlarm(
int nByte){
24042 if( mem0.alarmThreshold<=0 )
return;
24043 sqlite3_mutex_leave(mem0.mutex);
24044 sqlite3_release_memory(nByte);
24045 sqlite3_mutex_enter(mem0.mutex);
24052 static int mallocWithAlarm(
int n,
void **pp){
24055 assert( sqlite3_mutex_held(mem0.mutex) );
24056 nFull = sqlite3GlobalConfig.m.xRoundup(n);
24057 sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, n);
24058 if( mem0.alarmThreshold>0 ){
24059 sqlite3_int64 nUsed = sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED);
24060 if( nUsed >= mem0.alarmThreshold - nFull ){
24061 mem0.nearlyFull = 1;
24062 sqlite3MallocAlarm(nFull);
24064 mem0.nearlyFull = 0;
24067 p = sqlite3GlobalConfig.m.xMalloc(nFull);
24068 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT 24069 if( p==0 && mem0.alarmThreshold>0 ){
24070 sqlite3MallocAlarm(nFull);
24071 p = sqlite3GlobalConfig.m.xMalloc(nFull);
24075 nFull = sqlite3MallocSize(p);
24076 sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nFull);
24077 sqlite3StatusUp(SQLITE_STATUS_MALLOC_COUNT, 1);
24087 SQLITE_PRIVATE
void *sqlite3Malloc(u64 n){
24089 if( n==0 || n>=0x7fffff00 ){
24096 }
else if( sqlite3GlobalConfig.bMemstat ){
24097 sqlite3_mutex_enter(mem0.mutex);
24098 mallocWithAlarm((
int)n, &p);
24099 sqlite3_mutex_leave(mem0.mutex);
24101 p = sqlite3GlobalConfig.m.xMalloc((
int)n);
24103 assert( EIGHT_BYTE_ALIGNMENT(p) );
24112 SQLITE_API
void *SQLITE_STDCALL sqlite3_malloc(
int n){
24113 #ifndef SQLITE_OMIT_AUTOINIT 24114 if( sqlite3_initialize() )
return 0;
24116 return n<=0 ? 0 : sqlite3Malloc(n);
24118 SQLITE_API
void *SQLITE_STDCALL sqlite3_malloc64(sqlite3_uint64 n){
24119 #ifndef SQLITE_OMIT_AUTOINIT 24120 if( sqlite3_initialize() )
return 0;
24122 return sqlite3Malloc(n);
24131 #if SQLITE_THREADSAFE==0 && !defined(NDEBUG) 24132 static int scratchAllocOut = 0;
24144 SQLITE_PRIVATE
void *sqlite3ScratchMalloc(
int n){
24148 sqlite3_mutex_enter(mem0.mutex);
24149 sqlite3StatusHighwater(SQLITE_STATUS_SCRATCH_SIZE, n);
24150 if( mem0.nScratchFree && sqlite3GlobalConfig.szScratch>=n ){
24151 p = mem0.pScratchFree;
24152 mem0.pScratchFree = mem0.pScratchFree->pNext;
24153 mem0.nScratchFree--;
24154 sqlite3StatusUp(SQLITE_STATUS_SCRATCH_USED, 1);
24155 sqlite3_mutex_leave(mem0.mutex);
24157 sqlite3_mutex_leave(mem0.mutex);
24158 p = sqlite3Malloc(n);
24159 if( sqlite3GlobalConfig.bMemstat && p ){
24160 sqlite3_mutex_enter(mem0.mutex);
24161 sqlite3StatusUp(SQLITE_STATUS_SCRATCH_OVERFLOW, sqlite3MallocSize(p));
24162 sqlite3_mutex_leave(mem0.mutex);
24164 sqlite3MemdebugSetType(p, MEMTYPE_SCRATCH);
24166 assert( sqlite3_mutex_notheld(mem0.mutex) );
24169 #if SQLITE_THREADSAFE==0 && !defined(NDEBUG) 24175 assert( scratchAllocOut==0 );
24176 if( p ) scratchAllocOut++;
24181 SQLITE_PRIVATE
void sqlite3ScratchFree(
void *p){
24184 #if SQLITE_THREADSAFE==0 && !defined(NDEBUG) 24189 assert( scratchAllocOut>=1 && scratchAllocOut<=2 );
24193 if( SQLITE_WITHIN(p, sqlite3GlobalConfig.pScratch, mem0.pScratchEnd) ){
24197 sqlite3_mutex_enter(mem0.mutex);
24198 pSlot->pNext = mem0.pScratchFree;
24199 mem0.pScratchFree = pSlot;
24200 mem0.nScratchFree++;
24201 assert( mem0.nScratchFree <= (u32)sqlite3GlobalConfig.nScratch );
24202 sqlite3StatusDown(SQLITE_STATUS_SCRATCH_USED, 1);
24203 sqlite3_mutex_leave(mem0.mutex);
24206 assert( sqlite3MemdebugHasType(p, MEMTYPE_SCRATCH) );
24207 assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_SCRATCH) );
24208 sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
24209 if( sqlite3GlobalConfig.bMemstat ){
24210 int iSize = sqlite3MallocSize(p);
24211 sqlite3_mutex_enter(mem0.mutex);
24212 sqlite3StatusDown(SQLITE_STATUS_SCRATCH_OVERFLOW, iSize);
24213 sqlite3StatusDown(SQLITE_STATUS_MEMORY_USED, iSize);
24214 sqlite3StatusDown(SQLITE_STATUS_MALLOC_COUNT, 1);
24215 sqlite3GlobalConfig.m.xFree(p);
24216 sqlite3_mutex_leave(mem0.mutex);
24218 sqlite3GlobalConfig.m.xFree(p);
24227 #ifndef SQLITE_OMIT_LOOKASIDE 24228 static int isLookaside(
sqlite3 *db,
void *p){
24229 return SQLITE_WITHIN(p, db->lookaside.pStart, db->lookaside.pEnd);
24232 #define isLookaside(A,B) 0 24239 SQLITE_PRIVATE
int sqlite3MallocSize(
void *p){
24240 assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
24241 return sqlite3GlobalConfig.m.xSize(p);
24243 SQLITE_PRIVATE
int sqlite3DbMallocSize(
sqlite3 *db,
void *p){
24245 if( db==0 || !isLookaside(db,p) ){
24248 assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
24249 assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
24251 assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
24252 assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
24255 return sqlite3GlobalConfig.m.xSize(p);
24257 assert( sqlite3_mutex_held(db->mutex) );
24258 return db->lookaside.sz;
24261 SQLITE_API sqlite3_uint64 SQLITE_STDCALL sqlite3_msize(
void *p){
24262 assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
24263 assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
24264 return p ? sqlite3GlobalConfig.m.xSize(p) : 0;
24270 SQLITE_API
void SQLITE_STDCALL sqlite3_free(
void *p){
24272 assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
24273 assert( sqlite3MemdebugNoType(p, (u8)~MEMTYPE_HEAP) );
24274 if( sqlite3GlobalConfig.bMemstat ){
24275 sqlite3_mutex_enter(mem0.mutex);
24276 sqlite3StatusDown(SQLITE_STATUS_MEMORY_USED, sqlite3MallocSize(p));
24277 sqlite3StatusDown(SQLITE_STATUS_MALLOC_COUNT, 1);
24278 sqlite3GlobalConfig.m.xFree(p);
24279 sqlite3_mutex_leave(mem0.mutex);
24281 sqlite3GlobalConfig.m.xFree(p);
24289 static SQLITE_NOINLINE
void measureAllocationSize(
sqlite3 *db,
void *p){
24290 *db->pnBytesFreed += sqlite3DbMallocSize(db,p);
24297 SQLITE_PRIVATE
void sqlite3DbFree(
sqlite3 *db,
void *p){
24298 assert( db==0 || sqlite3_mutex_held(db->mutex) );
24301 if( db->pnBytesFreed ){
24302 measureAllocationSize(db, p);
24305 if( isLookaside(db, p) ){
24306 LookasideSlot *pBuf = (LookasideSlot*)p;
24309 memset(p, 0xaa, db->lookaside.sz);
24311 pBuf->pNext = db->lookaside.pFree;
24312 db->lookaside.pFree = pBuf;
24313 db->lookaside.nOut--;
24317 assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
24318 assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
24319 assert( db!=0 || sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) );
24320 sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
24327 SQLITE_PRIVATE
void *sqlite3Realloc(
void *pOld, u64 nBytes){
24328 int nOld, nNew, nDiff;
24330 assert( sqlite3MemdebugHasType(pOld, MEMTYPE_HEAP) );
24331 assert( sqlite3MemdebugNoType(pOld, (u8)~MEMTYPE_HEAP) );
24333 return sqlite3Malloc(nBytes);
24336 sqlite3_free(pOld);
24339 if( nBytes>=0x7fffff00 ){
24343 nOld = sqlite3MallocSize(pOld);
24347 nNew = sqlite3GlobalConfig.m.xRoundup((
int)nBytes);
24350 }
else if( sqlite3GlobalConfig.bMemstat ){
24351 sqlite3_mutex_enter(mem0.mutex);
24352 sqlite3StatusHighwater(SQLITE_STATUS_MALLOC_SIZE, (
int)nBytes);
24353 nDiff = nNew - nOld;
24354 if( sqlite3StatusValue(SQLITE_STATUS_MEMORY_USED) >=
24355 mem0.alarmThreshold-nDiff ){
24356 sqlite3MallocAlarm(nDiff);
24358 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
24359 if( pNew==0 && mem0.alarmThreshold>0 ){
24360 sqlite3MallocAlarm((
int)nBytes);
24361 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
24364 nNew = sqlite3MallocSize(pNew);
24365 sqlite3StatusUp(SQLITE_STATUS_MEMORY_USED, nNew-nOld);
24367 sqlite3_mutex_leave(mem0.mutex);
24369 pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
24371 assert( EIGHT_BYTE_ALIGNMENT(pNew) );
24379 SQLITE_API
void *SQLITE_STDCALL sqlite3_realloc(
void *pOld,
int n){
24380 #ifndef SQLITE_OMIT_AUTOINIT 24381 if( sqlite3_initialize() )
return 0;
24384 return sqlite3Realloc(pOld, n);
24386 SQLITE_API
void *SQLITE_STDCALL sqlite3_realloc64(
void *pOld, sqlite3_uint64 n){
24387 #ifndef SQLITE_OMIT_AUTOINIT 24388 if( sqlite3_initialize() )
return 0;
24390 return sqlite3Realloc(pOld, n);
24397 SQLITE_PRIVATE
void *sqlite3MallocZero(u64 n){
24398 void *p = sqlite3Malloc(n);
24400 memset(p, 0, (
size_t)n);
24409 SQLITE_PRIVATE
void *sqlite3DbMallocZero(
sqlite3 *db, u64 n){
24412 p = sqlite3DbMallocRaw(db, n);
24413 if( p ) memset(p, 0, (
size_t)n);
24421 static SQLITE_NOINLINE
void *dbMallocRawFinish(
sqlite3 *db, u64 n){
24424 p = sqlite3Malloc(n);
24425 if( !p ) sqlite3OomFault(db);
24426 sqlite3MemdebugSetType(p,
24427 (db->lookaside.bDisable==0) ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP);
24453 SQLITE_PRIVATE
void *sqlite3DbMallocRaw(
sqlite3 *db, u64 n){
24455 if( db )
return sqlite3DbMallocRawNN(db, n);
24456 p = sqlite3Malloc(n);
24457 sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
24460 SQLITE_PRIVATE
void *sqlite3DbMallocRawNN(
sqlite3 *db, u64 n){
24461 #ifndef SQLITE_OMIT_LOOKASIDE 24462 LookasideSlot *pBuf;
24464 assert( sqlite3_mutex_held(db->mutex) );
24465 assert( db->pnBytesFreed==0 );
24466 if( db->lookaside.bDisable==0 ){
24467 assert( db->mallocFailed==0 );
24468 if( n>db->lookaside.sz ){
24469 db->lookaside.anStat[1]++;
24470 }
else if( (pBuf = db->lookaside.pFree)==0 ){
24471 db->lookaside.anStat[2]++;
24473 db->lookaside.pFree = pBuf->pNext;
24474 db->lookaside.nOut++;
24475 db->lookaside.anStat[0]++;
24476 if( db->lookaside.nOut>db->lookaside.mxOut ){
24477 db->lookaside.mxOut = db->lookaside.nOut;
24479 return (
void*)pBuf;
24481 }
else if( db->mallocFailed ){
24486 assert( sqlite3_mutex_held(db->mutex) );
24487 assert( db->pnBytesFreed==0 );
24488 if( db->mallocFailed ){
24492 return dbMallocRawFinish(db, n);
24496 static SQLITE_NOINLINE
void *dbReallocFinish(
sqlite3 *db,
void *p, u64 n);
24502 SQLITE_PRIVATE
void *sqlite3DbRealloc(
sqlite3 *db,
void *p, u64 n){
24504 if( p==0 )
return sqlite3DbMallocRawNN(db, n);
24505 assert( sqlite3_mutex_held(db->mutex) );
24506 if( isLookaside(db,p) && n<=db->lookaside.sz )
return p;
24507 return dbReallocFinish(db, p, n);
24509 static SQLITE_NOINLINE
void *dbReallocFinish(
sqlite3 *db,
void *p, u64 n){
24513 if( db->mallocFailed==0 ){
24514 if( isLookaside(db, p) ){
24515 pNew = sqlite3DbMallocRawNN(db, n);
24517 memcpy(pNew, p, db->lookaside.sz);
24518 sqlite3DbFree(db, p);
24521 assert( sqlite3MemdebugHasType(p, (MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
24522 assert( sqlite3MemdebugNoType(p, (u8)~(MEMTYPE_LOOKASIDE|MEMTYPE_HEAP)) );
24523 sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
24524 pNew = sqlite3_realloc64(p, n);
24526 sqlite3OomFault(db);
24528 sqlite3MemdebugSetType(pNew,
24529 (db->lookaside.bDisable==0 ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP));
24539 SQLITE_PRIVATE
void *sqlite3DbReallocOrFree(
sqlite3 *db,
void *p, u64 n){
24541 pNew = sqlite3DbRealloc(db, p, n);
24543 sqlite3DbFree(db, p);
24555 SQLITE_PRIVATE
char *sqlite3DbStrDup(
sqlite3 *db,
const char *z){
24561 n = sqlite3Strlen30(z) + 1;
24562 assert( (n&0x7fffffff)==n );
24563 zNew = sqlite3DbMallocRaw(db, (
int)n);
24565 memcpy(zNew, z, n);
24569 SQLITE_PRIVATE
char *sqlite3DbStrNDup(
sqlite3 *db,
const char *z, u64 n){
24575 assert( (n&0x7fffffff)==n );
24576 zNew = sqlite3DbMallocRawNN(db, n+1);
24578 memcpy(zNew, z, (
size_t)n);
24587 SQLITE_PRIVATE
void sqlite3SetString(
char **pz,
sqlite3 *db,
const char *zNew){
24588 sqlite3DbFree(db, *pz);
24589 *pz = sqlite3DbStrDup(db, zNew);
24598 SQLITE_PRIVATE
void sqlite3OomFault(
sqlite3 *db){
24599 if( db->mallocFailed==0 && db->bBenignMalloc==0 ){
24600 db->mallocFailed = 1;
24601 if( db->nVdbeExec>0 ){
24602 db->u1.isInterrupted = 1;
24604 db->lookaside.bDisable++;
24615 SQLITE_PRIVATE
void sqlite3OomClear(
sqlite3 *db){
24616 if( db->mallocFailed && db->nVdbeExec==0 ){
24617 db->mallocFailed = 0;
24618 db->u1.isInterrupted = 0;
24619 assert( db->lookaside.bDisable>0 );
24620 db->lookaside.bDisable--;
24627 static SQLITE_NOINLINE
int apiOomError(
sqlite3 *db){
24628 sqlite3OomClear(db);
24629 sqlite3Error(db, SQLITE_NOMEM);
24630 return SQLITE_NOMEM_BKPT;
24645 SQLITE_PRIVATE
int sqlite3ApiExit(
sqlite3* db,
int rc){
24651 assert( sqlite3_mutex_held(db->mutex) );
24652 if( db->mallocFailed || rc==SQLITE_IOERR_NOMEM ){
24653 return apiOomError(db);
24655 return rc & db->errMask;
24680 #define etGENERIC 3 24683 #define etDYNSTRING 6 24684 #define etPERCENT 7 24687 #define etSQLESCAPE 9 24688 #define etSQLESCAPE2 10 24691 #define etSRCLIST 12 24692 #define etPOINTER 13 24693 #define etSQLESCAPE3 14 24694 #define etORDINAL 15 24696 #define etINVALID 16 24702 typedef unsigned char etByte;
24720 #define FLAG_SIGNED 1 24721 #define FLAG_INTERN 2 24722 #define FLAG_STRING 4 24729 static const char aDigits[] =
"0123456789ABCDEF0123456789abcdef";
24730 static const char aPrefix[] =
"-x0\000X0";
24731 static const et_info fmtinfo[] = {
24732 {
'd', 10, 1, etRADIX, 0, 0 },
24733 {
's', 0, 4, etSTRING, 0, 0 },
24734 {
'g', 0, 1, etGENERIC, 30, 0 },
24735 {
'z', 0, 4, etDYNSTRING, 0, 0 },
24736 {
'q', 0, 4, etSQLESCAPE, 0, 0 },
24737 {
'Q', 0, 4, etSQLESCAPE2, 0, 0 },
24738 {
'w', 0, 4, etSQLESCAPE3, 0, 0 },
24739 {
'c', 0, 0, etCHARX, 0, 0 },
24740 {
'o', 8, 0, etRADIX, 0, 2 },
24741 {
'u', 10, 0, etRADIX, 0, 0 },
24742 {
'x', 16, 0, etRADIX, 16, 1 },
24743 {
'X', 16, 0, etRADIX, 0, 4 },
24744 #ifndef SQLITE_OMIT_FLOATING_POINT 24745 {
'f', 0, 1, etFLOAT, 0, 0 },
24746 {
'e', 0, 1, etEXP, 30, 0 },
24747 {
'E', 0, 1, etEXP, 14, 0 },
24748 {
'G', 0, 1, etGENERIC, 14, 0 },
24750 {
'i', 10, 1, etRADIX, 0, 0 },
24751 {
'n', 0, 0, etSIZE, 0, 0 },
24752 {
'%', 0, 0, etPERCENT, 0, 0 },
24753 {
'p', 16, 0, etPOINTER, 0, 1 },
24757 {
'T', 0, 2, etTOKEN, 0, 0 },
24758 {
'S', 0, 2, etSRCLIST, 0, 0 },
24759 {
'r', 10, 3, etORDINAL, 0, 0 },
24766 #ifndef SQLITE_OMIT_FLOATING_POINT 24780 static char et_getdigit(LONGDOUBLE_TYPE *val,
int *cnt){
24783 if( (*cnt)<=0 )
return '0';
24788 *val = (*val - d)*10.0;
24789 return (
char)digit;
24796 static void setStrAccumError(StrAccum *p, u8 eError){
24797 assert( eError==STRACCUM_NOMEM || eError==STRACCUM_TOOBIG );
24798 p->accError = eError;
24805 static sqlite3_int64 getIntArg(PrintfArguments *p){
24806 if( p->nArg<=p->nUsed )
return 0;
24807 return sqlite3_value_int64(p->apArg[p->nUsed++]);
24809 static double getDoubleArg(PrintfArguments *p){
24810 if( p->nArg<=p->nUsed )
return 0.0;
24811 return sqlite3_value_double(p->apArg[p->nUsed++]);
24813 static char *getTextArg(PrintfArguments *p){
24814 if( p->nArg<=p->nUsed )
return 0;
24815 return (
char*)sqlite3_value_text(p->apArg[p->nUsed++]);
24823 #ifndef SQLITE_PRINT_BUF_SIZE 24824 # define SQLITE_PRINT_BUF_SIZE 70 24826 #define etBUFSIZE SQLITE_PRINT_BUF_SIZE 24831 SQLITE_PRIVATE
void sqlite3VXPrintf(
24842 etByte flag_leftjustify;
24843 etByte flag_plussign;
24844 etByte flag_blanksign;
24845 etByte flag_alternateform;
24846 etByte flag_altform2;
24847 etByte flag_zeropad;
24849 etByte flag_longlong;
24851 etByte xtype = etINVALID;
24855 sqlite_uint64 longvalue;
24856 LONGDOUBLE_TYPE realvalue;
24861 #ifndef SQLITE_OMIT_FLOATING_POINT 24868 PrintfArguments *pArgList = 0;
24869 char buf[etBUFSIZE];
24872 if( pAccum->printfFlags ){
24873 if( (bArgList = (pAccum->printfFlags & SQLITE_PRINTF_SQLFUNC))!=0 ){
24874 pArgList = va_arg(ap, PrintfArguments*);
24876 useIntern = pAccum->printfFlags & SQLITE_PRINTF_INTERNAL;
24878 bArgList = useIntern = 0;
24880 for(; (c=(*fmt))!=0; ++fmt){
24882 bufpt = (
char *)fmt;
24884 fmt = strchrnul(fmt,
'%');
24886 do{ fmt++; }
while( *fmt && *fmt !=
'%' );
24888 sqlite3StrAccumAppend(pAccum, bufpt, (
int)(fmt - bufpt));
24889 if( *fmt==0 )
break;
24891 if( (c=(*++fmt))==0 ){
24892 sqlite3StrAccumAppend(pAccum,
"%", 1);
24896 flag_leftjustify = flag_plussign = flag_blanksign =
24897 flag_alternateform = flag_altform2 = flag_zeropad = 0;
24901 case '-': flag_leftjustify = 1;
break;
24902 case '+': flag_plussign = 1;
break;
24903 case ' ': flag_blanksign = 1;
break;
24904 case '#': flag_alternateform = 1;
break;
24905 case '!': flag_altform2 = 1;
break;
24906 case '0': flag_zeropad = 1;
break;
24907 default: done = 1;
break;
24909 }
while( !done && (c=(*++fmt))!=0 );
24913 width = (int)getIntArg(pArgList);
24915 width = va_arg(ap,
int);
24918 flag_leftjustify = 1;
24919 width = width >= -2147483647 ? -width : 0;
24924 while( c>=
'0' && c<=
'9' ){
24925 wx = wx*10 + c -
'0';
24928 testcase( wx>0x7fffffff );
24929 width = wx & 0x7fffffff;
24931 assert( width>=0 );
24932 #ifdef SQLITE_PRINTF_PRECISION_LIMIT 24933 if( width>SQLITE_PRINTF_PRECISION_LIMIT ){
24934 width = SQLITE_PRINTF_PRECISION_LIMIT;
24943 precision = (int)getIntArg(pArgList);
24945 precision = va_arg(ap,
int);
24949 precision = precision >= -2147483647 ? -precision : -1;
24953 while( c>=
'0' && c<=
'9' ){
24954 px = px*10 + c -
'0';
24957 testcase( px>0x7fffffff );
24958 precision = px & 0x7fffffff;
24963 assert( precision>=(-1) );
24964 #ifdef SQLITE_PRINTF_PRECISION_LIMIT 24965 if( precision>SQLITE_PRINTF_PRECISION_LIMIT ){
24966 precision = SQLITE_PRINTF_PRECISION_LIMIT;
24982 flag_long = flag_longlong = 0;
24985 infop = &fmtinfo[0];
24987 for(idx=0; idx<ArraySize(fmtinfo); idx++){
24988 if( c==fmtinfo[idx].fmttype ){
24989 infop = &fmtinfo[idx];
24990 if( useIntern || (infop->flags & FLAG_INTERN)==0 ){
24991 xtype = infop->type;
25022 flag_longlong =
sizeof(
char*)==
sizeof(i64);
25023 flag_long =
sizeof(
char*)==
sizeof(
long int);
25027 if( infop->flags & FLAG_SIGNED ){
25030 v = getIntArg(pArgList);
25031 }
else if( flag_longlong ){
25032 v = va_arg(ap,i64);
25033 }
else if( flag_long ){
25034 v = va_arg(ap,
long int);
25036 v = va_arg(ap,
int);
25039 if( v==SMALLEST_INT64 ){
25040 longvalue = ((u64)1)<<63;
25047 if( flag_plussign ) prefix =
'+';
25048 else if( flag_blanksign ) prefix =
' ';
25053 longvalue = (u64)getIntArg(pArgList);
25054 }
else if( flag_longlong ){
25055 longvalue = va_arg(ap,u64);
25056 }
else if( flag_long ){
25057 longvalue = va_arg(ap,
unsigned long int);
25059 longvalue = va_arg(ap,
unsigned int);
25063 if( longvalue==0 ) flag_alternateform = 0;
25064 if( flag_zeropad && precision<width-(prefix!=0) ){
25065 precision = width-(prefix!=0);
25067 if( precision<etBUFSIZE-10 ){
25071 nOut = precision + 10;
25072 zOut = zExtra = sqlite3Malloc( nOut );
25074 setStrAccumError(pAccum, STRACCUM_NOMEM);
25078 bufpt = &zOut[nOut-1];
25079 if( xtype==etORDINAL ){
25080 static const char zOrd[] =
"thstndrd";
25081 int x = (int)(longvalue % 10);
25082 if( x>=4 || (longvalue/10)%10==1 ){
25085 *(--bufpt) = zOrd[x*2+1];
25086 *(--bufpt) = zOrd[x*2];
25089 const char *cset = &aDigits[infop->charset];
25090 u8 base = infop->base;
25092 *(--bufpt) = cset[longvalue%base];
25093 longvalue = longvalue/base;
25094 }
while( longvalue>0 );
25096 length = (int)(&zOut[nOut-1]-bufpt);
25097 for(idx=precision-length; idx>0; idx--){
25100 if( prefix ) *(--bufpt) = prefix;
25101 if( flag_alternateform && infop->prefix ){
25104 pre = &aPrefix[infop->prefix];
25105 for(; (x=(*pre))!=0; pre++) *(--bufpt) = x;
25107 length = (int)(&zOut[nOut-1]-bufpt);
25113 realvalue = getDoubleArg(pArgList);
25115 realvalue = va_arg(ap,
double);
25117 #ifdef SQLITE_OMIT_FLOATING_POINT 25120 if( precision<0 ) precision = 6;
25121 if( realvalue<0.0 ){
25122 realvalue = -realvalue;
25125 if( flag_plussign ) prefix =
'+';
25126 else if( flag_blanksign ) prefix =
' ';
25129 if( xtype==etGENERIC && precision>0 ) precision--;
25130 testcase( precision>0xfff );
25131 for(idx=precision&0xfff, rounder=0.5; idx>0; idx--, rounder*=0.1){}
25132 if( xtype==etFLOAT ) realvalue += rounder;
25135 if( sqlite3IsNaN((
double)realvalue) ){
25140 if( realvalue>0.0 ){
25141 LONGDOUBLE_TYPE scale = 1.0;
25142 while( realvalue>=1e100*scale && exp<=350 ){ scale *= 1e100;exp+=100;}
25143 while( realvalue>=1e10*scale && exp<=350 ){ scale *= 1e10; exp+=10; }
25144 while( realvalue>=10.0*scale && exp<=350 ){ scale *= 10.0; exp++; }
25145 realvalue /= scale;
25146 while( realvalue<1e-8 ){ realvalue *= 1e8; exp-=8; }
25147 while( realvalue<1.0 ){ realvalue *= 10.0; exp--; }
25151 memcpy(buf+(prefix!=0),
"Inf",4);
25152 length = 3+(prefix!=0);
25161 if( xtype!=etFLOAT ){
25162 realvalue += rounder;
25163 if( realvalue>=10.0 ){ realvalue *= 0.1; exp++; }
25165 if( xtype==etGENERIC ){
25166 flag_rtz = !flag_alternateform;
25167 if( exp<-4 || exp>precision ){
25170 precision = precision - exp;
25174 flag_rtz = flag_altform2;
25176 if( xtype==etEXP ){
25181 if( MAX(e2,0)+(i64)precision+(i64)width > etBUFSIZE - 15 ){
25183 = sqlite3Malloc( MAX(e2,0)+(i64)precision+(i64)width+15 );
25185 setStrAccumError(pAccum, STRACCUM_NOMEM);
25190 nsd = 16 + flag_altform2*10;
25191 flag_dp = (precision>0 ?1:0) | flag_alternateform | flag_altform2;
25194 *(bufpt++) = prefix;
25200 for(; e2>=0; e2--){
25201 *(bufpt++) = et_getdigit(&realvalue,&nsd);
25210 for(e2++; e2<0; precision--, e2++){
25211 assert( precision>0 );
25215 while( (precision--)>0 ){
25216 *(bufpt++) = et_getdigit(&realvalue,&nsd);
25219 if( flag_rtz && flag_dp ){
25220 while( bufpt[-1]==
'0' ) *(--bufpt) = 0;
25221 assert( bufpt>zOut );
25222 if( bufpt[-1]==
'.' ){
25223 if( flag_altform2 ){
25231 if( xtype==etEXP ){
25232 *(bufpt++) = aDigits[infop->charset];
25234 *(bufpt++) =
'-'; exp = -exp;
25239 *(bufpt++) = (
char)((exp/100)+
'0');
25242 *(bufpt++) = (
char)(exp/10+
'0');
25243 *(bufpt++) = (
char)(exp%10+
'0');
25250 length = (int)(bufpt-zOut);
25255 if( flag_zeropad && !flag_leftjustify && length < width){
25257 int nPad = width - length;
25258 for(i=width; i>=nPad; i--){
25259 bufpt[i] = bufpt[i-nPad];
25262 while( nPad-- ) bufpt[i++] =
'0';
25269 *(va_arg(ap,
int*)) = pAccum->nChar;
25271 length = width = 0;
25280 bufpt = getTextArg(pArgList);
25281 c = bufpt ? bufpt[0] : 0;
25283 c = va_arg(ap,
int);
25286 width -= precision-1;
25287 if( width>1 && !flag_leftjustify ){
25288 sqlite3AppendChar(pAccum, width-1,
' ');
25291 sqlite3AppendChar(pAccum, precision-1, c);
25300 bufpt = getTextArg(pArgList);
25303 bufpt = va_arg(ap,
char*);
25307 }
else if( xtype==etDYNSTRING ){
25310 if( precision>=0 ){
25311 for(length=0; length<precision && bufpt[length]; length++){}
25313 length = sqlite3Strlen30(bufpt);
25318 case etSQLESCAPE3: {
25319 int i, j, k, n, isnull;
25322 char q = ((xtype==etSQLESCAPE3)?
'"':
'\'');
25326 escarg = getTextArg(pArgList);
25328 escarg = va_arg(ap,
char*);
25330 isnull = escarg==0;
25331 if( isnull ) escarg = (xtype==etSQLESCAPE2 ?
"NULL" :
"(NULL)");
25333 for(i=n=0; k!=0 && (ch=escarg[i])!=0; i++, k--){
25336 needQuote = !isnull && xtype==etSQLESCAPE2;
25339 bufpt = zExtra = sqlite3Malloc( n );
25341 setStrAccumError(pAccum, STRACCUM_NOMEM);
25348 if( needQuote ) bufpt[j++] = q;
25350 for(i=0; i<k; i++){
25351 bufpt[j++] = ch = escarg[i];
25352 if( ch==q ) bufpt[j++] = ch;
25354 if( needQuote ) bufpt[j++] = q;
25363 Token *pToken = va_arg(ap, Token*);
25364 assert( bArgList==0 );
25365 if( pToken && pToken->n ){
25366 sqlite3StrAccumAppend(pAccum, (
const char*)pToken->z, pToken->n);
25368 length = width = 0;
25372 SrcList *pSrc = va_arg(ap, SrcList*);
25373 int k = va_arg(ap,
int);
25374 struct SrcList_item *pItem = &pSrc->a[k];
25375 assert( bArgList==0 );
25376 assert( k>=0 && k<pSrc->nSrc );
25377 if( pItem->zDatabase ){
25378 sqlite3StrAccumAppendAll(pAccum, pItem->zDatabase);
25379 sqlite3StrAccumAppend(pAccum,
".", 1);
25381 sqlite3StrAccumAppendAll(pAccum, pItem->zName);
25382 length = width = 0;
25386 assert( xtype==etINVALID );
25396 if( width>0 && !flag_leftjustify ) sqlite3AppendChar(pAccum, width,
' ');
25397 sqlite3StrAccumAppend(pAccum, bufpt, length);
25398 if( width>0 && flag_leftjustify ) sqlite3AppendChar(pAccum, width,
' ');
25401 sqlite3DbFree(pAccum->db, zExtra);
25414 static int sqlite3StrAccumEnlarge(StrAccum *p,
int N){
25416 assert( p->nChar+(i64)N >= p->nAlloc );
25418 testcase(p->accError==STRACCUM_TOOBIG);
25419 testcase(p->accError==STRACCUM_NOMEM);
25422 if( p->mxAlloc==0 ){
25423 N = p->nAlloc - p->nChar - 1;
25424 setStrAccumError(p, STRACCUM_TOOBIG);
25427 char *zOld = isMalloced(p) ? p->zText : 0;
25428 i64 szNew = p->nChar;
25429 assert( (p->zText==0 || p->zText==p->zBase)==!isMalloced(p) );
25431 if( szNew+p->nChar<=p->mxAlloc ){
25436 if( szNew > p->mxAlloc ){
25437 sqlite3StrAccumReset(p);
25438 setStrAccumError(p, STRACCUM_TOOBIG);
25441 p->nAlloc = (int)szNew;
25444 zNew = sqlite3DbRealloc(p->db, zOld, p->nAlloc);
25446 zNew = sqlite3_realloc64(zOld, p->nAlloc);
25449 assert( p->zText!=0 || p->nChar==0 );
25450 if( !isMalloced(p) && p->nChar>0 ) memcpy(zNew, p->zText, p->nChar);
25452 p->nAlloc = sqlite3DbMallocSize(p->db, zNew);
25453 p->printfFlags |= SQLITE_PRINTF_MALLOCED;
25455 sqlite3StrAccumReset(p);
25456 setStrAccumError(p, STRACCUM_NOMEM);
25466 SQLITE_PRIVATE
void sqlite3AppendChar(StrAccum *p,
int N,
char c){
25467 testcase( p->nChar + (i64)N > 0x7fffffff );
25468 if( p->nChar+(i64)N >= p->nAlloc && (N = sqlite3StrAccumEnlarge(p, N))<=0 ){
25471 assert( (p->zText==p->zBase)==!isMalloced(p) );
25472 while( (N--)>0 ) p->zText[p->nChar++] = c;
25483 static void SQLITE_NOINLINE enlargeAndAppend(StrAccum *p,
const char *z,
int N){
25484 N = sqlite3StrAccumEnlarge(p, N);
25486 memcpy(&p->zText[p->nChar], z, N);
25489 assert( (p->zText==0 || p->zText==p->zBase)==!isMalloced(p) );
25496 SQLITE_PRIVATE
void sqlite3StrAccumAppend(StrAccum *p,
const char *z,
int N){
25497 assert( z!=0 || N==0 );
25498 assert( p->zText!=0 || p->nChar==0 || p->accError );
25500 assert( p->accError==0 || p->nAlloc==0 );
25501 if( p->nChar+N >= p->nAlloc ){
25502 enlargeAndAppend(p,z,N);
25504 assert( p->zText );
25506 memcpy(&p->zText[p->nChar-N], z, N);
25513 SQLITE_PRIVATE
void sqlite3StrAccumAppendAll(StrAccum *p,
const char *z){
25514 sqlite3StrAccumAppend(p, z, sqlite3Strlen30(z));
25523 SQLITE_PRIVATE
char *sqlite3StrAccumFinish(StrAccum *p){
25525 assert( (p->zText==p->zBase)==!isMalloced(p) );
25526 p->zText[p->nChar] = 0;
25527 if( p->mxAlloc>0 && !isMalloced(p) ){
25528 p->zText = sqlite3DbMallocRaw(p->db, p->nChar+1 );
25530 memcpy(p->zText, p->zBase, p->nChar+1);
25531 p->printfFlags |= SQLITE_PRINTF_MALLOCED;
25533 setStrAccumError(p, STRACCUM_NOMEM);
25543 SQLITE_PRIVATE
void sqlite3StrAccumReset(StrAccum *p){
25544 assert( (p->zText==0 || p->zText==p->zBase)==!isMalloced(p) );
25545 if( isMalloced(p) ){
25546 sqlite3DbFree(p->db, p->zText);
25547 p->printfFlags &= ~SQLITE_PRINTF_MALLOCED;
25566 SQLITE_PRIVATE
void sqlite3StrAccumInit(StrAccum *p,
sqlite3 *db,
char *zBase,
int n,
int mx){
25567 p->zText = p->zBase = zBase;
25573 p->printfFlags = 0;
25580 SQLITE_PRIVATE
char *sqlite3VMPrintf(
sqlite3 *db,
const char *zFormat, va_list ap){
25582 char zBase[SQLITE_PRINT_BUF_SIZE];
25585 sqlite3StrAccumInit(&acc, db, zBase,
sizeof(zBase),
25586 db->aLimit[SQLITE_LIMIT_LENGTH]);
25587 acc.printfFlags = SQLITE_PRINTF_INTERNAL;
25588 sqlite3VXPrintf(&acc, zFormat, ap);
25589 z = sqlite3StrAccumFinish(&acc);
25590 if( acc.accError==STRACCUM_NOMEM ){
25591 sqlite3OomFault(db);
25600 SQLITE_PRIVATE
char *sqlite3MPrintf(
sqlite3 *db,
const char *zFormat, ...){
25603 va_start(ap, zFormat);
25604 z = sqlite3VMPrintf(db, zFormat, ap);
25613 SQLITE_API
char *SQLITE_STDCALL sqlite3_vmprintf(
const char *zFormat, va_list ap){
25615 char zBase[SQLITE_PRINT_BUF_SIZE];
25618 #ifdef SQLITE_ENABLE_API_ARMOR 25620 (void)SQLITE_MISUSE_BKPT;
25624 #ifndef SQLITE_OMIT_AUTOINIT 25625 if( sqlite3_initialize() )
return 0;
25627 sqlite3StrAccumInit(&acc, 0, zBase,
sizeof(zBase), SQLITE_MAX_LENGTH);
25628 sqlite3VXPrintf(&acc, zFormat, ap);
25629 z = sqlite3StrAccumFinish(&acc);
25637 SQLITE_API
char *SQLITE_CDECL sqlite3_mprintf(
const char *zFormat, ...){
25640 #ifndef SQLITE_OMIT_AUTOINIT 25641 if( sqlite3_initialize() )
return 0;
25643 va_start(ap, zFormat);
25644 z = sqlite3_vmprintf(zFormat, ap);
25662 SQLITE_API
char *SQLITE_STDCALL sqlite3_vsnprintf(
int n,
char *zBuf,
const char *zFormat, va_list ap){
25664 if( n<=0 )
return zBuf;
25665 #ifdef SQLITE_ENABLE_API_ARMOR 25666 if( zBuf==0 || zFormat==0 ) {
25667 (void)SQLITE_MISUSE_BKPT;
25668 if( zBuf ) zBuf[0] = 0;
25672 sqlite3StrAccumInit(&acc, 0, zBuf, n, 0);
25673 sqlite3VXPrintf(&acc, zFormat, ap);
25674 return sqlite3StrAccumFinish(&acc);
25676 SQLITE_API
char *SQLITE_CDECL sqlite3_snprintf(
int n,
char *zBuf,
const char *zFormat, ...){
25679 va_start(ap,zFormat);
25680 z = sqlite3_vsnprintf(n, zBuf, zFormat, ap);
25699 static void renderLogMsg(
int iErrCode,
const char *zFormat, va_list ap){
25701 char zMsg[SQLITE_PRINT_BUF_SIZE*3];
25703 sqlite3StrAccumInit(&acc, 0, zMsg,
sizeof(zMsg), 0);
25704 sqlite3VXPrintf(&acc, zFormat, ap);
25705 sqlite3GlobalConfig.xLog(sqlite3GlobalConfig.pLogArg, iErrCode,
25706 sqlite3StrAccumFinish(&acc));
25712 SQLITE_API
void SQLITE_CDECL sqlite3_log(
int iErrCode,
const char *zFormat, ...){
25714 if( sqlite3GlobalConfig.xLog ){
25715 va_start(ap, zFormat);
25716 renderLogMsg(iErrCode, zFormat, ap);
25721 #if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE) 25727 SQLITE_PRIVATE
void sqlite3DebugPrintf(
const char *zFormat, ...){
25731 sqlite3StrAccumInit(&acc, 0, zBuf,
sizeof(zBuf), 0);
25732 va_start(ap,zFormat);
25733 sqlite3VXPrintf(&acc, zFormat, ap);
25735 sqlite3StrAccumFinish(&acc);
25736 fprintf(stdout,
"%s", zBuf);
25746 SQLITE_PRIVATE
void sqlite3XPrintf(StrAccum *p,
const char *zFormat, ...){
25748 va_start(ap,zFormat);
25749 sqlite3VXPrintf(p, zFormat, ap);
25775 #ifdef SQLITE_DEBUG 25781 static TreeView *sqlite3TreeViewPush(TreeView *p, u8 moreToFollow){
25783 p = sqlite3_malloc64(
sizeof(*p) );
25784 if( p==0 )
return 0;
25785 memset(p, 0,
sizeof(*p));
25789 assert( moreToFollow==0 || moreToFollow==1 );
25790 if( p->iLevel<
sizeof(p->bLine) ) p->bLine[p->iLevel] = moreToFollow;
25797 static void sqlite3TreeViewPop(TreeView *p){
25800 if( p->iLevel<0 ) sqlite3_free(p);
25807 static void sqlite3TreeViewLine(TreeView *p,
const char *zFormat, ...){
25812 sqlite3StrAccumInit(&acc, 0, zBuf,
sizeof(zBuf), 0);
25814 for(i=0; i<p->iLevel && i<
sizeof(p->bLine)-1; i++){
25815 sqlite3StrAccumAppend(&acc, p->bLine[i] ?
"| " :
" ", 4);
25817 sqlite3StrAccumAppend(&acc, p->bLine[i] ?
"|-- " :
"'-- ", 4);
25819 va_start(ap, zFormat);
25820 sqlite3VXPrintf(&acc, zFormat, ap);
25822 if( zBuf[acc.nChar-1]!=
'\n' ) sqlite3StrAccumAppend(&acc,
"\n", 1);
25823 sqlite3StrAccumFinish(&acc);
25824 fprintf(stdout,
"%s", zBuf);
25831 static void sqlite3TreeViewItem(TreeView *p,
const char *zLabel,u8 moreFollows){
25832 p = sqlite3TreeViewPush(p, moreFollows);
25833 sqlite3TreeViewLine(p,
"%s", zLabel);
25839 SQLITE_PRIVATE
void sqlite3TreeViewWith(TreeView *pView,
const With *pWith, u8 moreToFollow){
25841 if( pWith==0 )
return;
25842 if( pWith->nCte==0 )
return;
25843 if( pWith->pOuter ){
25844 sqlite3TreeViewLine(pView,
"WITH (0x%p, pOuter=0x%p)",pWith,pWith->pOuter);
25846 sqlite3TreeViewLine(pView,
"WITH (0x%p)", pWith);
25848 if( pWith->nCte>0 ){
25849 pView = sqlite3TreeViewPush(pView, 1);
25850 for(i=0; i<pWith->nCte; i++){
25853 const struct Cte *pCte = &pWith->a[i];
25854 sqlite3StrAccumInit(&x, 0, zLine,
sizeof(zLine), 0);
25855 sqlite3XPrintf(&x,
"%s", pCte->zName);
25856 if( pCte->pCols && pCte->pCols->nExpr>0 ){
25859 for(j=0; j<pCte->pCols->nExpr; j++){
25860 sqlite3XPrintf(&x,
"%c%s", cSep, pCte->pCols->a[j].zName);
25863 sqlite3XPrintf(&x,
")");
25865 sqlite3XPrintf(&x,
" AS");
25866 sqlite3StrAccumFinish(&x);
25867 sqlite3TreeViewItem(pView, zLine, i<pWith->nCte-1);
25868 sqlite3TreeViewSelect(pView, pCte->pSelect, 0);
25869 sqlite3TreeViewPop(pView);
25871 sqlite3TreeViewPop(pView);
25879 SQLITE_PRIVATE
void sqlite3TreeViewSelect(TreeView *pView,
const Select *p, u8 moreToFollow){
25882 pView = sqlite3TreeViewPush(pView, moreToFollow);
25884 sqlite3TreeViewWith(pView, p->pWith, 1);
25886 sqlite3TreeViewPush(pView, 1);
25889 sqlite3TreeViewLine(pView,
"SELECT%s%s (0x%p) selFlags=0x%x nSelectRow=%d",
25890 ((p->selFlags & SF_Distinct) ?
" DISTINCT" :
""),
25891 ((p->selFlags & SF_Aggregate) ?
" agg_flag" :
""), p, p->selFlags,
25894 if( cnt++ ) sqlite3TreeViewPop(pView);
25899 if( p->pSrc && p->pSrc->nSrc ) n++;
25900 if( p->pWhere ) n++;
25901 if( p->pGroupBy ) n++;
25902 if( p->pHaving ) n++;
25903 if( p->pOrderBy ) n++;
25904 if( p->pLimit ) n++;
25905 if( p->pOffset ) n++;
25907 sqlite3TreeViewExprList(pView, p->pEList, (n--)>0,
"result-set");
25908 if( p->pSrc && p->pSrc->nSrc ){
25910 pView = sqlite3TreeViewPush(pView, (n--)>0);
25911 sqlite3TreeViewLine(pView,
"FROM");
25912 for(i=0; i<p->pSrc->nSrc; i++){
25913 struct SrcList_item *pItem = &p->pSrc->a[i];
25916 sqlite3StrAccumInit(&x, 0, zLine,
sizeof(zLine), 0);
25917 sqlite3XPrintf(&x,
"{%d,*}", pItem->iCursor);
25918 if( pItem->zDatabase ){
25919 sqlite3XPrintf(&x,
" %s.%s", pItem->zDatabase, pItem->zName);
25920 }
else if( pItem->zName ){
25921 sqlite3XPrintf(&x,
" %s", pItem->zName);
25924 sqlite3XPrintf(&x,
" tabname=%Q", pItem->pTab->zName);
25926 if( pItem->zAlias ){
25927 sqlite3XPrintf(&x,
" (AS %s)", pItem->zAlias);
25929 if( pItem->fg.jointype & JT_LEFT ){
25930 sqlite3XPrintf(&x,
" LEFT-JOIN");
25932 sqlite3StrAccumFinish(&x);
25933 sqlite3TreeViewItem(pView, zLine, i<p->pSrc->nSrc-1);
25934 if( pItem->pSelect ){
25935 sqlite3TreeViewSelect(pView, pItem->pSelect, 0);
25937 if( pItem->fg.isTabFunc ){
25938 sqlite3TreeViewExprList(pView, pItem->u1.pFuncArg, 0,
"func-args:");
25940 sqlite3TreeViewPop(pView);
25942 sqlite3TreeViewPop(pView);
25945 sqlite3TreeViewItem(pView,
"WHERE", (n--)>0);
25946 sqlite3TreeViewExpr(pView, p->pWhere, 0);
25947 sqlite3TreeViewPop(pView);
25950 sqlite3TreeViewExprList(pView, p->pGroupBy, (n--)>0,
"GROUPBY");
25953 sqlite3TreeViewItem(pView,
"HAVING", (n--)>0);
25954 sqlite3TreeViewExpr(pView, p->pHaving, 0);
25955 sqlite3TreeViewPop(pView);
25958 sqlite3TreeViewExprList(pView, p->pOrderBy, (n--)>0,
"ORDERBY");
25961 sqlite3TreeViewItem(pView,
"LIMIT", (n--)>0);
25962 sqlite3TreeViewExpr(pView, p->pLimit, 0);
25963 sqlite3TreeViewPop(pView);
25966 sqlite3TreeViewItem(pView,
"OFFSET", (n--)>0);
25967 sqlite3TreeViewExpr(pView, p->pOffset, 0);
25968 sqlite3TreeViewPop(pView);
25971 const char *zOp =
"UNION";
25973 case TK_ALL: zOp =
"UNION ALL";
break;
25974 case TK_INTERSECT: zOp =
"INTERSECT";
break;
25975 case TK_EXCEPT: zOp =
"EXCEPT";
break;
25977 sqlite3TreeViewItem(pView, zOp, 1);
25981 sqlite3TreeViewPop(pView);
25987 SQLITE_PRIVATE
void sqlite3TreeViewExpr(TreeView *pView,
const Expr *pExpr, u8 moreToFollow){
25988 const char *zBinOp = 0;
25989 const char *zUniOp = 0;
25991 pView = sqlite3TreeViewPush(pView, moreToFollow);
25993 sqlite3TreeViewLine(pView,
"nil");
25994 sqlite3TreeViewPop(pView);
25997 if( pExpr->flags ){
25998 sqlite3_snprintf(
sizeof(zFlgs),zFlgs,
" flags=0x%x",pExpr->flags);
26002 switch( pExpr->op ){
26003 case TK_AGG_COLUMN: {
26004 sqlite3TreeViewLine(pView,
"AGG{%d:%d}%s",
26005 pExpr->iTable, pExpr->iColumn, zFlgs);
26009 if( pExpr->iTable<0 ){
26011 sqlite3TreeViewLine(pView,
"COLUMN(%d)%s", pExpr->iColumn, zFlgs);
26013 sqlite3TreeViewLine(pView,
"{%d:%d}%s",
26014 pExpr->iTable, pExpr->iColumn, zFlgs);
26019 if( pExpr->flags & EP_IntValue ){
26020 sqlite3TreeViewLine(pView,
"%d", pExpr->u.iValue);
26022 sqlite3TreeViewLine(pView,
"%s", pExpr->u.zToken);
26026 #ifndef SQLITE_OMIT_FLOATING_POINT 26028 sqlite3TreeViewLine(pView,
"%s", pExpr->u.zToken);
26033 sqlite3TreeViewLine(pView,
"%Q", pExpr->u.zToken);
26037 sqlite3TreeViewLine(pView,
"NULL");
26040 #ifndef SQLITE_OMIT_BLOB_LITERAL 26042 sqlite3TreeViewLine(pView,
"%s", pExpr->u.zToken);
26046 case TK_VARIABLE: {
26047 sqlite3TreeViewLine(pView,
"VARIABLE(%s,%d)",
26048 pExpr->u.zToken, pExpr->iColumn);
26051 case TK_REGISTER: {
26052 sqlite3TreeViewLine(pView,
"REGISTER(%d)", pExpr->iTable);
26056 sqlite3TreeViewLine(pView,
"ID \"%w\"", pExpr->u.zToken);
26059 #ifndef SQLITE_OMIT_CAST 26062 sqlite3TreeViewLine(pView,
"CAST %Q", pExpr->u.zToken);
26063 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
26067 case TK_LT: zBinOp =
"LT";
break;
26068 case TK_LE: zBinOp =
"LE";
break;
26069 case TK_GT: zBinOp =
"GT";
break;
26070 case TK_GE: zBinOp =
"GE";
break;
26071 case TK_NE: zBinOp =
"NE";
break;
26072 case TK_EQ: zBinOp =
"EQ";
break;
26073 case TK_IS: zBinOp =
"IS";
break;
26074 case TK_ISNOT: zBinOp =
"ISNOT";
break;
26075 case TK_AND: zBinOp =
"AND";
break;
26076 case TK_OR: zBinOp =
"OR";
break;
26077 case TK_PLUS: zBinOp =
"ADD";
break;
26078 case TK_STAR: zBinOp =
"MUL";
break;
26079 case TK_MINUS: zBinOp =
"SUB";
break;
26080 case TK_REM: zBinOp =
"REM";
break;
26081 case TK_BITAND: zBinOp =
"BITAND";
break;
26082 case TK_BITOR: zBinOp =
"BITOR";
break;
26083 case TK_SLASH: zBinOp =
"DIV";
break;
26084 case TK_LSHIFT: zBinOp =
"LSHIFT";
break;
26085 case TK_RSHIFT: zBinOp =
"RSHIFT";
break;
26086 case TK_CONCAT: zBinOp =
"CONCAT";
break;
26087 case TK_DOT: zBinOp =
"DOT";
break;
26089 case TK_UMINUS: zUniOp =
"UMINUS";
break;
26090 case TK_UPLUS: zUniOp =
"UPLUS";
break;
26091 case TK_BITNOT: zUniOp =
"BITNOT";
break;
26092 case TK_NOT: zUniOp =
"NOT";
break;
26093 case TK_ISNULL: zUniOp =
"ISNULL";
break;
26094 case TK_NOTNULL: zUniOp =
"NOTNULL";
break;
26097 sqlite3TreeViewLine(pView,
"SPAN %Q", pExpr->u.zToken);
26098 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
26103 sqlite3TreeViewLine(pView,
"COLLATE %Q", pExpr->u.zToken);
26104 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
26108 case TK_AGG_FUNCTION:
26109 case TK_FUNCTION: {
26111 if( ExprHasProperty(pExpr, EP_TokenOnly) ){
26114 pFarg = pExpr->x.pList;
26116 if( pExpr->op==TK_AGG_FUNCTION ){
26117 sqlite3TreeViewLine(pView,
"AGG_FUNCTION%d %Q",
26118 pExpr->op2, pExpr->u.zToken);
26120 sqlite3TreeViewLine(pView,
"FUNCTION %Q", pExpr->u.zToken);
26123 sqlite3TreeViewExprList(pView, pFarg, 0, 0);
26127 #ifndef SQLITE_OMIT_SUBQUERY 26129 sqlite3TreeViewLine(pView,
"EXISTS-expr");
26130 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0);
26134 sqlite3TreeViewLine(pView,
"SELECT-expr");
26135 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0);
26139 sqlite3TreeViewLine(pView,
"IN");
26140 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1);
26141 if( ExprHasProperty(pExpr, EP_xIsSelect) ){
26142 sqlite3TreeViewSelect(pView, pExpr->x.pSelect, 0);
26144 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0);
26162 Expr *pX = pExpr->pLeft;
26163 Expr *pY = pExpr->x.pList->a[0].pExpr;
26164 Expr *pZ = pExpr->x.pList->a[1].pExpr;
26165 sqlite3TreeViewLine(pView,
"BETWEEN");
26166 sqlite3TreeViewExpr(pView, pX, 1);
26167 sqlite3TreeViewExpr(pView, pY, 1);
26168 sqlite3TreeViewExpr(pView, pZ, 0);
26179 sqlite3TreeViewLine(pView,
"%s(%d)",
26180 pExpr->iTable ?
"NEW" :
"OLD", pExpr->iColumn);
26184 sqlite3TreeViewLine(pView,
"CASE");
26185 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1);
26186 sqlite3TreeViewExprList(pView, pExpr->x.pList, 0, 0);
26189 #ifndef SQLITE_OMIT_TRIGGER 26191 const char *zType =
"unk";
26192 switch( pExpr->affinity ){
26193 case OE_Rollback: zType =
"rollback";
break;
26194 case OE_Abort: zType =
"abort";
break;
26195 case OE_Fail: zType =
"fail";
break;
26196 case OE_Ignore: zType =
"ignore";
break;
26198 sqlite3TreeViewLine(pView,
"RAISE %s(%Q)", zType, pExpr->u.zToken);
26203 sqlite3TreeViewLine(pView,
"MATCH {%d:%d}%s",
26204 pExpr->iTable, pExpr->iColumn, zFlgs);
26205 sqlite3TreeViewExpr(pView, pExpr->pRight, 0);
26209 sqlite3TreeViewLine(pView,
"op=%d", pExpr->op);
26214 sqlite3TreeViewLine(pView,
"%s%s", zBinOp, zFlgs);
26215 sqlite3TreeViewExpr(pView, pExpr->pLeft, 1);
26216 sqlite3TreeViewExpr(pView, pExpr->pRight, 0);
26217 }
else if( zUniOp ){
26218 sqlite3TreeViewLine(pView,
"%s%s", zUniOp, zFlgs);
26219 sqlite3TreeViewExpr(pView, pExpr->pLeft, 0);
26221 sqlite3TreeViewPop(pView);
26227 SQLITE_PRIVATE
void sqlite3TreeViewExprList(
26229 const ExprList *pList,
26234 pView = sqlite3TreeViewPush(pView, moreToFollow);
26235 if( zLabel==0 || zLabel[0]==0 ) zLabel =
"LIST";
26237 sqlite3TreeViewLine(pView,
"%s (empty)", zLabel);
26239 sqlite3TreeViewLine(pView,
"%s", zLabel);
26240 for(i=0; i<pList->nExpr; i++){
26241 int j = pList->a[i].u.x.iOrderByCol;
26243 sqlite3TreeViewPush(pView, 0);
26244 sqlite3TreeViewLine(pView,
"iOrderByCol=%d", j);
26246 sqlite3TreeViewExpr(pView, pList->a[i].pExpr, i<pList->nExpr-1);
26247 if( j ) sqlite3TreeViewPop(pView);
26250 sqlite3TreeViewPop(pView);
26280 static SQLITE_WSD
struct sqlite3PrngType {
26281 unsigned char isInit;
26282 unsigned char i, j;
26283 unsigned char s[256];
26289 SQLITE_API
void SQLITE_STDCALL sqlite3_randomness(
int N,
void *pBuf){
26291 unsigned char *zBuf = pBuf;
26299 #ifdef SQLITE_OMIT_WSD 26300 struct sqlite3PrngType *p = &GLOBAL(
struct sqlite3PrngType, sqlite3Prng);
26301 # define wsdPrng p[0] 26303 # define wsdPrng sqlite3Prng 26306 #if SQLITE_THREADSAFE 26310 #ifndef SQLITE_OMIT_AUTOINIT 26311 if( sqlite3_initialize() )
return;
26314 #if SQLITE_THREADSAFE 26315 mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_PRNG);
26318 sqlite3_mutex_enter(mutex);
26319 if( N<=0 || pBuf==0 ){
26320 wsdPrng.isInit = 0;
26321 sqlite3_mutex_leave(mutex);
26334 if( !wsdPrng.isInit ){
26339 sqlite3OsRandomness(sqlite3_vfs_find(0), 256, k);
26340 for(i=0; i<256; i++){
26341 wsdPrng.s[i] = (u8)i;
26343 for(i=0; i<256; i++){
26344 wsdPrng.j += wsdPrng.s[i] + k[i];
26345 t = wsdPrng.s[wsdPrng.j];
26346 wsdPrng.s[wsdPrng.j] = wsdPrng.s[i];
26349 wsdPrng.isInit = 1;
26355 t = wsdPrng.s[wsdPrng.i];
26357 wsdPrng.s[wsdPrng.i] = wsdPrng.s[wsdPrng.j];
26358 wsdPrng.s[wsdPrng.j] = t;
26359 t += wsdPrng.s[wsdPrng.i];
26360 *(zBuf++) = wsdPrng.s[t];
26362 sqlite3_mutex_leave(mutex);
26365 #ifndef SQLITE_OMIT_BUILTIN_TEST 26375 static SQLITE_WSD
struct sqlite3PrngType sqlite3SavedPrng;
26376 SQLITE_PRIVATE
void sqlite3PrngSaveState(
void){
26378 &GLOBAL(
struct sqlite3PrngType, sqlite3SavedPrng),
26379 &GLOBAL(
struct sqlite3PrngType, sqlite3Prng),
26380 sizeof(sqlite3Prng)
26383 SQLITE_PRIVATE
void sqlite3PrngRestoreState(
void){
26385 &GLOBAL(
struct sqlite3PrngType, sqlite3Prng),
26386 &GLOBAL(
struct sqlite3PrngType, sqlite3SavedPrng),
26387 sizeof(sqlite3Prng)
26426 #if SQLITE_MAX_WORKER_THREADS>0 26429 #if SQLITE_OS_UNIX && defined(SQLITE_MUTEX_PTHREADS) && SQLITE_THREADSAFE>0 26431 #define SQLITE_THREADS_IMPLEMENTED 1 26435 struct SQLiteThread {
26439 void *(*xTask)(
void*);
26444 SQLITE_PRIVATE
int sqlite3ThreadCreate(
26445 SQLiteThread **ppThread,
26446 void *(*xTask)(
void*),
26452 assert( ppThread!=0 );
26453 assert( xTask!=0 );
26455 assert( sqlite3GlobalConfig.bCoreMutex!=0 );
26458 p = sqlite3Malloc(
sizeof(*p));
26459 if( p==0 )
return SQLITE_NOMEM_BKPT;
26460 memset(p, 0,
sizeof(*p));
26467 if( sqlite3FaultSim(200) ){
26470 rc = pthread_create(&p->tid, 0, xTask, pIn);
26474 p->pOut = xTask(pIn);
26481 SQLITE_PRIVATE
int sqlite3ThreadJoin(SQLiteThread *p,
void **ppOut){
26484 assert( ppOut!=0 );
26485 if( NEVER(p==0) )
return SQLITE_NOMEM_BKPT;
26490 rc = pthread_join(p->tid, ppOut) ? SQLITE_ERROR : SQLITE_OK;
26501 #if SQLITE_OS_WIN_THREADS 26503 #define SQLITE_THREADS_IMPLEMENTED 1 26504 #include <process.h> 26507 struct SQLiteThread {
26510 void *(*xTask)(
void*);
26516 static unsigned __stdcall sqlite3ThreadProc(
26519 SQLiteThread *p = (SQLiteThread *)pArg;
26529 assert( p->id==GetCurrentThreadId() );
26531 assert( p->xTask!=0 );
26532 p->pResult = p->xTask(p->pIn);
26539 SQLITE_PRIVATE
int sqlite3ThreadCreate(
26540 SQLiteThread **ppThread,
26541 void *(*xTask)(
void*),
26546 assert( ppThread!=0 );
26547 assert( xTask!=0 );
26549 p = sqlite3Malloc(
sizeof(*p));
26550 if( p==0 )
return SQLITE_NOMEM_BKPT;
26556 if( sqlite3GlobalConfig.bCoreMutex==0 || sqlite3FaultSim(200) ){
26557 memset(p, 0,
sizeof(*p));
26561 p->tid = (
void*)_beginthreadex(0, 0, sqlite3ThreadProc, p, 0, &p->id);
26563 memset(p, 0,
sizeof(*p));
26567 p->id = GetCurrentThreadId();
26568 p->pResult = xTask(pIn);
26574 SQLITE_PRIVATE DWORD sqlite3Win32Wait(HANDLE hObject);
26577 SQLITE_PRIVATE
int sqlite3ThreadJoin(SQLiteThread *p,
void **ppOut){
26581 assert( ppOut!=0 );
26582 if( NEVER(p==0) )
return SQLITE_NOMEM_BKPT;
26585 rc = WAIT_OBJECT_0;
26586 assert( p->tid==0 );
26588 assert( p->id!=0 && p->id!=GetCurrentThreadId() );
26589 rc = sqlite3Win32Wait((HANDLE)p->tid);
26590 assert( rc!=WAIT_IO_COMPLETION );
26591 bRc = CloseHandle((HANDLE)p->tid);
26594 if( rc==WAIT_OBJECT_0 ) *ppOut = p->pResult;
26596 return (rc==WAIT_OBJECT_0) ? SQLITE_OK : SQLITE_ERROR;
26604 #ifndef SQLITE_THREADS_IMPLEMENTED 26612 struct SQLiteThread {
26613 void *(*xTask)(
void*);
26619 SQLITE_PRIVATE
int sqlite3ThreadCreate(
26620 SQLiteThread **ppThread,
26621 void *(*xTask)(
void*),
26626 assert( ppThread!=0 );
26627 assert( xTask!=0 );
26629 p = sqlite3Malloc(
sizeof(*p));
26630 if( p==0 )
return SQLITE_NOMEM_BKPT;
26631 if( (SQLITE_PTR_TO_INT(p)/17)&1 ){
26636 p->pResult = xTask(pIn);
26643 SQLITE_PRIVATE
int sqlite3ThreadJoin(SQLiteThread *p,
void **ppOut){
26645 assert( ppOut!=0 );
26646 if( NEVER(p==0) )
return SQLITE_NOMEM_BKPT;
26648 *ppOut = p->xTask(p->pIn);
26650 *ppOut = p->pResult;
26654 #if defined(SQLITE_TEST) 26656 void *pTstAlloc = sqlite3Malloc(10);
26657 if (!pTstAlloc)
return SQLITE_NOMEM_BKPT;
26658 sqlite3_free(pTstAlloc);
26710 #if !defined(SQLITE_AMALGAMATION) && SQLITE_BYTEORDER==0 26715 SQLITE_PRIVATE
const int sqlite3one = 1;
26722 static const unsigned char sqlite3Utf8Trans1[] = {
26723 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
26724 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
26725 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
26726 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
26727 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
26728 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
26729 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
26730 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x00, 0x00,
26734 #define WRITE_UTF8(zOut, c) { \ 26736 *zOut++ = (u8)(c&0xFF); \ 26738 else if( c<0x00800 ){ \ 26739 *zOut++ = 0xC0 + (u8)((c>>6)&0x1F); \ 26740 *zOut++ = 0x80 + (u8)(c & 0x3F); \ 26742 else if( c<0x10000 ){ \ 26743 *zOut++ = 0xE0 + (u8)((c>>12)&0x0F); \ 26744 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); \ 26745 *zOut++ = 0x80 + (u8)(c & 0x3F); \ 26747 *zOut++ = 0xF0 + (u8)((c>>18) & 0x07); \ 26748 *zOut++ = 0x80 + (u8)((c>>12) & 0x3F); \ 26749 *zOut++ = 0x80 + (u8)((c>>6) & 0x3F); \ 26750 *zOut++ = 0x80 + (u8)(c & 0x3F); \ 26754 #define WRITE_UTF16LE(zOut, c) { \ 26756 *zOut++ = (u8)(c&0x00FF); \ 26757 *zOut++ = (u8)((c>>8)&0x00FF); \ 26759 *zOut++ = (u8)(((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0)); \ 26760 *zOut++ = (u8)(0x00D8 + (((c-0x10000)>>18)&0x03)); \ 26761 *zOut++ = (u8)(c&0x00FF); \ 26762 *zOut++ = (u8)(0x00DC + ((c>>8)&0x03)); \ 26766 #define WRITE_UTF16BE(zOut, c) { \ 26768 *zOut++ = (u8)((c>>8)&0x00FF); \ 26769 *zOut++ = (u8)(c&0x00FF); \ 26771 *zOut++ = (u8)(0x00D8 + (((c-0x10000)>>18)&0x03)); \ 26772 *zOut++ = (u8)(((c>>10)&0x003F) + (((c-0x10000)>>10)&0x00C0)); \ 26773 *zOut++ = (u8)(0x00DC + ((c>>8)&0x03)); \ 26774 *zOut++ = (u8)(c&0x00FF); \ 26778 #define READ_UTF16LE(zIn, TERM, c){ \ 26780 c += ((*zIn++)<<8); \ 26781 if( c>=0xD800 && c<0xE000 && TERM ){ \ 26782 int c2 = (*zIn++); \ 26783 c2 += ((*zIn++)<<8); \ 26784 c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10); \ 26788 #define READ_UTF16BE(zIn, TERM, c){ \ 26789 c = ((*zIn++)<<8); \ 26791 if( c>=0xD800 && c<0xE000 && TERM ){ \ 26792 int c2 = ((*zIn++)<<8); \ 26794 c = (c2&0x03FF) + ((c&0x003F)<<10) + (((c&0x03C0)+0x0040)<<10); \ 26825 #define READ_UTF8(zIn, zTerm, c) \ 26828 c = sqlite3Utf8Trans1[c-0xc0]; \ 26829 while( zIn!=zTerm && (*zIn & 0xc0)==0x80 ){ \ 26830 c = (c<<6) + (0x3f & *(zIn++)); \ 26833 || (c&0xFFFFF800)==0xD800 \ 26834 || (c&0xFFFFFFFE)==0xFFFE ){ c = 0xFFFD; } \ 26836 SQLITE_PRIVATE u32 sqlite3Utf8Read(
26837 const unsigned char **pz
26846 c = sqlite3Utf8Trans1[c-0xc0];
26847 while( (*(*pz) & 0xc0)==0x80 ){
26848 c = (c<<6) + (0x3f & *((*pz)++));
26851 || (c&0xFFFFF800)==0xD800
26852 || (c&0xFFFFFFFE)==0xFFFE ){ c = 0xFFFD; }
26866 #ifndef SQLITE_OMIT_UTF16 26872 SQLITE_PRIVATE SQLITE_NOINLINE
int sqlite3VdbeMemTranslate(Mem *pMem, u8 desiredEnc){
26874 unsigned char *zOut;
26875 unsigned char *zIn;
26876 unsigned char *zTerm;
26880 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
26881 assert( pMem->flags&MEM_Str );
26882 assert( pMem->enc!=desiredEnc );
26883 assert( pMem->enc!=0 );
26884 assert( pMem->n>=0 );
26886 #if defined(TRANSLATE_TRACE) && defined(SQLITE_DEBUG) 26889 sqlite3VdbeMemPrettyPrint(pMem, zBuf);
26890 fprintf(stderr,
"INPUT: %s\n", zBuf);
26898 if( pMem->enc!=SQLITE_UTF8 && desiredEnc!=SQLITE_UTF8 ){
26901 rc = sqlite3VdbeMemMakeWriteable(pMem);
26902 if( rc!=SQLITE_OK ){
26903 assert( rc==SQLITE_NOMEM );
26904 return SQLITE_NOMEM_BKPT;
26906 zIn = (u8*)pMem->z;
26907 zTerm = &zIn[pMem->n&~1];
26908 while( zIn<zTerm ){
26914 pMem->enc = desiredEnc;
26915 goto translate_out;
26919 if( desiredEnc==SQLITE_UTF8 ){
26926 len = pMem->n * 2 + 1;
26933 len = pMem->n * 2 + 2;
26942 zIn = (u8*)pMem->z;
26943 zTerm = &zIn[pMem->n];
26944 zOut = sqlite3DbMallocRaw(pMem->db, len);
26946 return SQLITE_NOMEM_BKPT;
26950 if( pMem->enc==SQLITE_UTF8 ){
26951 if( desiredEnc==SQLITE_UTF16LE ){
26953 while( zIn<zTerm ){
26954 READ_UTF8(zIn, zTerm, c);
26955 WRITE_UTF16LE(z, c);
26958 assert( desiredEnc==SQLITE_UTF16BE );
26960 while( zIn<zTerm ){
26961 READ_UTF8(zIn, zTerm, c);
26962 WRITE_UTF16BE(z, c);
26965 pMem->n = (int)(z - zOut);
26968 assert( desiredEnc==SQLITE_UTF8 );
26969 if( pMem->enc==SQLITE_UTF16LE ){
26971 while( zIn<zTerm ){
26972 READ_UTF16LE(zIn, zIn<zTerm, c);
26977 while( zIn<zTerm ){
26978 READ_UTF16BE(zIn, zIn<zTerm, c);
26982 pMem->n = (int)(z - zOut);
26985 assert( (pMem->n+(desiredEnc==SQLITE_UTF8?1:2))<=len );
26988 sqlite3VdbeMemRelease(pMem);
26989 pMem->flags = MEM_Str|MEM_Term|(c&(MEM_AffMask|MEM_Subtype));
26990 pMem->enc = desiredEnc;
26991 pMem->z = (
char*)zOut;
26992 pMem->zMalloc = pMem->z;
26993 pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->z);
26996 #if defined(TRANSLATE_TRACE) && defined(SQLITE_DEBUG) 26999 sqlite3VdbeMemPrettyPrint(pMem, zBuf);
27000 fprintf(stderr,
"OUTPUT: %s\n", zBuf);
27015 SQLITE_PRIVATE
int sqlite3VdbeMemHandleBom(Mem *pMem){
27016 int rc = SQLITE_OK;
27019 assert( pMem->n>=0 );
27021 u8 b1 = *(u8 *)pMem->z;
27022 u8 b2 = *(((u8 *)pMem->z) + 1);
27023 if( b1==0xFE && b2==0xFF ){
27024 bom = SQLITE_UTF16BE;
27026 if( b1==0xFF && b2==0xFE ){
27027 bom = SQLITE_UTF16LE;
27032 rc = sqlite3VdbeMemMakeWriteable(pMem);
27033 if( rc==SQLITE_OK ){
27035 memmove(pMem->z, &pMem->z[2], pMem->n);
27036 pMem->z[pMem->n] =
'\0';
27037 pMem->z[pMem->n+1] =
'\0';
27038 pMem->flags |= MEM_Term;
27053 SQLITE_PRIVATE
int sqlite3Utf8CharLen(
const char *zIn,
int nByte){
27055 const u8 *z = (
const u8*)zIn;
27060 zTerm = (
const u8*)(-1);
27062 assert( z<=zTerm );
27063 while( *z!=0 && z<zTerm ){
27064 SQLITE_SKIP_UTF8(z);
27073 #if defined(SQLITE_TEST) && defined(SQLITE_DEBUG) 27083 SQLITE_PRIVATE
int sqlite3Utf8To8(
unsigned char *zIn){
27084 unsigned char *zOut = zIn;
27085 unsigned char *zStart = zIn;
27088 while( zIn[0] && zOut<=zIn ){
27089 c = sqlite3Utf8Read((
const u8**)&zIn);
27091 WRITE_UTF8(zOut, c);
27095 return (
int)(zOut - zStart);
27099 #ifndef SQLITE_OMIT_UTF16 27107 SQLITE_PRIVATE
char *sqlite3Utf16to8(
sqlite3 *db,
const void *z,
int nByte, u8 enc){
27109 memset(&m, 0,
sizeof(m));
27111 sqlite3VdbeMemSetStr(&m, z, nByte, enc, SQLITE_STATIC);
27112 sqlite3VdbeChangeEncoding(&m, SQLITE_UTF8);
27113 if( db->mallocFailed ){
27114 sqlite3VdbeMemRelease(&m);
27117 assert( (m.flags & MEM_Term)!=0 || db->mallocFailed );
27118 assert( (m.flags & MEM_Str)!=0 || db->mallocFailed );
27119 assert( m.z || db->mallocFailed );
27128 SQLITE_PRIVATE
int sqlite3Utf16ByteLen(
const void *zIn,
int nChar){
27130 unsigned char const *z = zIn;
27133 if( SQLITE_UTF16NATIVE==SQLITE_UTF16BE ){
27135 READ_UTF16BE(z, 1, c);
27140 READ_UTF16LE(z, 1, c);
27144 return (
int)(z-(
unsigned char const *)zIn);
27147 #if defined(SQLITE_TEST) 27153 SQLITE_PRIVATE
void sqlite3UtfSelfTest(
void){
27155 unsigned char zBuf[20];
27160 for(i=0; i<0x00110000; i++){
27164 assert( n>0 && n<=4 );
27167 c = sqlite3Utf8Read((
const u8**)&z);
27169 if( i>=0xD800 && i<=0xDFFF ) t = 0xFFFD;
27170 if( (i&0xFFFFFFFE)==0xFFFE ) t = 0xFFFD;
27172 assert( (z-zBuf)==n );
27174 for(i=0; i<0x00110000; i++){
27175 if( i>=0xD800 && i<0xE000 )
continue;
27177 WRITE_UTF16LE(z, i);
27179 assert( n>0 && n<=4 );
27182 READ_UTF16LE(z, 1, c);
27184 assert( (z-zBuf)==n );
27186 for(i=0; i<0x00110000; i++){
27187 if( i>=0xD800 && i<0xE000 )
continue;
27189 WRITE_UTF16BE(z, i);
27191 assert( n>0 && n<=4 );
27194 READ_UTF16BE(z, 1, c);
27196 assert( (z-zBuf)==n );
27223 #if HAVE_ISNAN || SQLITE_HAVE_ISNAN 27230 #ifdef SQLITE_COVERAGE_TEST 27231 SQLITE_PRIVATE
void sqlite3Coverage(
int x){
27232 static unsigned dummy = 0;
27233 dummy += (unsigned)x;
27248 #ifndef SQLITE_OMIT_BUILTIN_TEST 27249 SQLITE_PRIVATE
int sqlite3FaultSim(
int iTest){
27250 int (*xCallback)(int) = sqlite3GlobalConfig.xTestCallback;
27251 return xCallback ? xCallback(iTest) : SQLITE_OK;
27255 #ifndef SQLITE_OMIT_FLOATING_POINT 27262 SQLITE_PRIVATE
int sqlite3IsNaN(
double x){
27264 #if !SQLITE_HAVE_ISNAN && !HAVE_ISNAN 27288 #ifdef __FAST_MATH__ 27289 # error SQLite will not work correctly with the -ffast-math option of GCC. 27291 volatile double y = x;
27292 volatile double z = y;
27310 SQLITE_PRIVATE
int sqlite3Strlen30(
const char *z){
27311 if( z==0 )
return 0;
27312 return 0x3fffffff & (int)strlen(z);
27322 SQLITE_PRIVATE
char *sqlite3ColumnType(Column *pCol,
char *zDflt){
27323 if( (pCol->colFlags & COLFLAG_HASTYPE)==0 )
return zDflt;
27324 return pCol->zName + strlen(pCol->zName) + 1;
27332 static SQLITE_NOINLINE
void sqlite3ErrorFinish(
sqlite3 *db,
int err_code){
27333 if( db->pErr ) sqlite3ValueSetNull(db->pErr);
27334 sqlite3SystemError(db, err_code);
27342 SQLITE_PRIVATE
void sqlite3Error(
sqlite3 *db,
int err_code){
27344 db->errCode = err_code;
27345 if( err_code || db->pErr ) sqlite3ErrorFinish(db, err_code);
27352 SQLITE_PRIVATE
void sqlite3SystemError(
sqlite3 *db,
int rc){
27353 if( rc==SQLITE_IOERR_NOMEM )
return;
27355 if( rc==SQLITE_CANTOPEN || rc==SQLITE_IOERR ){
27356 db->iSysErrno = sqlite3OsGetLastError(db->pVfs);
27381 SQLITE_PRIVATE
void sqlite3ErrorWithMsg(
sqlite3 *db,
int err_code,
const char *zFormat, ...){
27383 db->errCode = err_code;
27384 sqlite3SystemError(db, err_code);
27386 sqlite3Error(db, err_code);
27387 }
else if( db->pErr || (db->pErr = sqlite3ValueNew(db))!=0 ){
27390 va_start(ap, zFormat);
27391 z = sqlite3VMPrintf(db, zFormat, ap);
27393 sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC);
27414 SQLITE_PRIVATE
void sqlite3ErrorMsg(Parse *pParse,
const char *zFormat, ...){
27418 va_start(ap, zFormat);
27419 zMsg = sqlite3VMPrintf(db, zFormat, ap);
27421 if( db->suppressErr ){
27422 sqlite3DbFree(db, zMsg);
27425 sqlite3DbFree(db, pParse->zErrMsg);
27426 pParse->zErrMsg = zMsg;
27427 pParse->rc = SQLITE_ERROR;
27448 SQLITE_PRIVATE
void sqlite3Dequote(
char *z){
27453 if( !sqlite3Isquote(quote) )
return;
27454 if( quote==
'[' ) quote =
']';
27455 for(i=1, j=0;; i++){
27458 if( z[i+1]==quote ){
27474 SQLITE_PRIVATE
void sqlite3TokenInit(Token *p,
char *z){
27476 p->n = sqlite3Strlen30(z);
27480 #define UpperToLower sqlite3UpperToLower 27492 SQLITE_API
int SQLITE_STDCALL sqlite3_stricmp(
const char *zLeft,
const char *zRight){
27494 return zRight ? -1 : 0;
27495 }
else if( zRight==0 ){
27498 return sqlite3StrICmp(zLeft, zRight);
27500 SQLITE_PRIVATE
int sqlite3StrICmp(
const char *zLeft,
const char *zRight){
27501 unsigned char *a, *b;
27503 a = (
unsigned char *)zLeft;
27504 b = (
unsigned char *)zRight;
27506 c = (int)UpperToLower[*a] - (
int)UpperToLower[*b];
27507 if( c || *a==0 )
break;
27513 SQLITE_API
int SQLITE_STDCALL sqlite3_strnicmp(
const char *zLeft,
const char *zRight,
int N){
27514 register unsigned char *a, *b;
27516 return zRight ? -1 : 0;
27517 }
else if( zRight==0 ){
27520 a = (
unsigned char *)zLeft;
27521 b = (
unsigned char *)zRight;
27522 while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; }
27523 return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b];
27548 SQLITE_PRIVATE
int sqlite3AtoF(
const char *z,
double *pResult,
int length, u8 enc){
27549 #ifndef SQLITE_OMIT_FLOATING_POINT 27551 const char *zEnd = z + length;
27563 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
27566 if( enc==SQLITE_UTF8 ){
27571 assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
27572 for(i=3-enc; i<length && z[i]==0; i+=2){}
27579 while( z<zEnd && sqlite3Isspace(*z) ) z+=incr;
27580 if( z>=zEnd )
return 0;
27586 }
else if( *z==
'+' ){
27591 while( z<zEnd && sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){
27592 s = s*10 + (*z -
'0');
27593 z+=incr, nDigits++;
27598 while( z<zEnd && sqlite3Isdigit(*z) ) z+=incr, nDigits++, d++;
27599 if( z>=zEnd )
goto do_atof_calc;
27606 while( z<zEnd && sqlite3Isdigit(*z) ){
27607 if( s<((LARGEST_INT64-9)/10) ){
27608 s = s*10 + (*z -
'0');
27611 z+=incr, nDigits++;
27614 if( z>=zEnd )
goto do_atof_calc;
27617 if( *z==
'e' || *z==
'E' ){
27624 if( z>=zEnd )
goto do_atof_calc;
27630 }
else if( *z==
'+' ){
27634 while( z<zEnd && sqlite3Isdigit(*z) ){
27635 e = e<10000 ? (e*10 + (*z -
'0')) : 10000;
27642 while( z<zEnd && sqlite3Isspace(*z) ) z+=incr;
27656 result = sign<0 ? -(double)0 : (
double)0;
27666 if( s>=(LARGEST_INT64/10) )
break;
27669 if( s%10!=0 )
break;
27676 s = sign<0 ? -s : s;
27679 result = (double)s;
27681 LONGDOUBLE_TYPE scale = 1.0;
27685 while( e%308 ) { scale *= 1.0e+1; e -= 1; }
27687 result = s / scale;
27688 result /= 1.0e+308;
27690 result = s * scale;
27691 result *= 1.0e+308;
27693 }
else{ assert( e>=342 );
27697 result = 1e308*1e308*s;
27703 while( e%22 ) { scale *= 1.0e+1; e -= 1; }
27704 while( e>0 ) { scale *= 1.0e+22; e -= 22; }
27706 result = s / scale;
27708 result = s * scale;
27718 return z==zEnd && nDigits>0 && eValid && nonNum==0;
27720 return !sqlite3Atoi64(z, pResult, length, enc);
27738 static int compare2pow63(
const char *zNum,
int incr){
27742 const char *pow63 =
"922337203685477580";
27743 for(i=0; c==0 && i<18; i++){
27744 c = (zNum[i*incr]-pow63[i])*10;
27747 c = zNum[18*incr] -
'8';
27748 testcase( c==(-1) );
27750 testcase( c==(+1) );
27774 SQLITE_PRIVATE
int sqlite3Atoi64(
const char *zNum, i64 *pNum,
int length, u8 enc){
27781 const char *zStart;
27782 const char *zEnd = zNum + length;
27783 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
27784 if( enc==SQLITE_UTF8 ){
27788 assert( SQLITE_UTF16LE==2 && SQLITE_UTF16BE==3 );
27789 for(i=3-enc; i<length && zNum[i]==0; i+=2){}
27794 while( zNum<zEnd && sqlite3Isspace(*zNum) ) zNum+=incr;
27799 }
else if( *zNum==
'+' ){
27804 while( zNum<zEnd && zNum[0]==
'0' ){ zNum+=incr; }
27805 for(i=0; &zNum[i]<zEnd && (c=zNum[i])>=
'0' && c<=
'9'; i+=incr){
27806 u = u*10 + c -
'0';
27808 if( u>LARGEST_INT64 ){
27809 *pNum = neg ? SMALLEST_INT64 : LARGEST_INT64;
27819 || (i==0 && zStart==zNum)
27826 }
else if( i<19*incr ){
27828 assert( u<=LARGEST_INT64 );
27832 c = compare2pow63(zNum, incr);
27835 assert( u<=LARGEST_INT64 );
27843 assert( u-1==LARGEST_INT64 );
27844 return neg ? 0 : 2;
27860 SQLITE_PRIVATE
int sqlite3DecOrHexToI64(
const char *z, i64 *pOut){
27861 #ifndef SQLITE_OMIT_HEX_INTEGER 27863 && (z[1]==
'x' || z[1]==
'X')
27867 for(i=2; z[i]==
'0'; i++){}
27868 for(k=i; sqlite3Isxdigit(z[k]); k++){
27869 u = u*16 + sqlite3HexToInt(z[k]);
27871 memcpy(pOut, &u, 8);
27872 return (z[k]==0 && k-i<=16) ? 0 : 1;
27876 return sqlite3Atoi64(z, pOut, sqlite3Strlen30(z), SQLITE_UTF8);
27890 SQLITE_PRIVATE
int sqlite3GetInt32(
const char *zNum,
int *pValue){
27891 sqlite_int64 v = 0;
27894 if( zNum[0]==
'-' ){
27897 }
else if( zNum[0]==
'+' ){
27900 #ifndef SQLITE_OMIT_HEX_INTEGER 27901 else if( zNum[0]==
'0' 27902 && (zNum[1]==
'x' || zNum[1]==
'X')
27903 && sqlite3Isxdigit(zNum[2])
27907 while( zNum[0]==
'0' ) zNum++;
27908 for(i=0; sqlite3Isxdigit(zNum[i]) && i<8; i++){
27909 u = u*16 + sqlite3HexToInt(zNum[i]);
27911 if( (u&0x80000000)==0 && sqlite3Isxdigit(zNum[i])==0 ){
27912 memcpy(pValue, &u, 4);
27919 while( zNum[0]==
'0' ) zNum++;
27920 for(i=0; i<11 && (c = zNum[i] -
'0')>=0 && c<=9; i++){
27933 testcase( v-neg==2147483647 );
27934 if( v-neg>2147483647 ){
27948 SQLITE_PRIVATE
int sqlite3Atoi(
const char *z){
27950 if( z ) sqlite3GetInt32(z, &x);
27983 static int SQLITE_NOINLINE putVarint64(
unsigned char *p, u64 v){
27986 if( v & (((u64)0xff000000)<<32) ){
27989 for(i=7; i>=0; i--){
27990 p[i] = (u8)((v & 0x7f) | 0x80);
27997 buf[n++] = (u8)((v & 0x7f) | 0x80);
28002 for(i=0, j=n-1; j>=0; j--, i++){
28007 SQLITE_PRIVATE
int sqlite3PutVarint(
unsigned char *p, u64 v){
28013 p[0] = ((v>>7)&0x7f)|0x80;
28017 return putVarint64(p,v);
28029 #define SLOT_2_0 0x001fc07f 28030 #define SLOT_4_2_0 0xf01fc07f 28037 SQLITE_PRIVATE u8 sqlite3GetVarint(
const unsigned char *p, u64 *v){
28061 assert( SLOT_2_0 == ((0x7f<<14) | (0x7f)) );
28062 assert( SLOT_4_2_0 == ((0xfU<<28) | (0x7f<<14) | (0x7f)) );
28117 *v = ((u64)s)<<32 | a;
28138 *v = ((u64)s)<<32 | a;
28153 *v = ((u64)s)<<32 | a;
28171 *v = ((u64)s)<<32 | a;
28192 *v = ((u64)s)<<32 | a;
28208 SQLITE_PRIVATE u8 sqlite3GetVarint32(
const unsigned char *p, u32 *v){
28215 #ifndef getVarint32 28245 a &= (0x7f<<14)|(0x7f);
28267 n = sqlite3GetVarint(p, &v64);
28268 assert( n>3 && n<=9 );
28269 if( (v64 & SQLITE_MAX_U32)!=v64 ){
28289 b &= (0x7f<<14)|(0x7f);
28290 a &= (0x7f<<14)|(0x7f);
28319 n = sqlite3GetVarint(p, &v64);
28320 assert( n>5 && n<=9 );
28331 SQLITE_PRIVATE
int sqlite3VarintLen(u64 v){
28333 for(i=1; (v >>= 7)!=0; i++){ assert( i<10 ); }
28341 SQLITE_PRIVATE u32 sqlite3Get4byte(
const u8 *p){
28342 #if SQLITE_BYTEORDER==4321 28346 #elif SQLITE_BYTEORDER==1234 && !defined(SQLITE_DISABLE_INTRINSIC) \ 28347 && defined(__GNUC__) && GCC_VERSION>=4003000 28350 return __builtin_bswap32(x);
28351 #elif SQLITE_BYTEORDER==1234 && !defined(SQLITE_DISABLE_INTRINSIC) \ 28352 && defined(_MSC_VER) && _MSC_VER>=1300 28355 return _byteswap_ulong(x);
28357 testcase( p[0]&0x80 );
28358 return ((
unsigned)p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3];
28361 SQLITE_PRIVATE
void sqlite3Put4byte(
unsigned char *p, u32 v){
28362 #if SQLITE_BYTEORDER==4321 28364 #elif SQLITE_BYTEORDER==1234 && !defined(SQLITE_DISABLE_INTRINSIC) \ 28365 && defined(__GNUC__) && GCC_VERSION>=4003000 28366 u32 x = __builtin_bswap32(v);
28368 #elif SQLITE_BYTEORDER==1234 && !defined(SQLITE_DISABLE_INTRINSIC) \ 28369 && defined(_MSC_VER) && _MSC_VER>=1300 28370 u32 x = _byteswap_ulong(v);
28373 p[0] = (u8)(v>>24);
28374 p[1] = (u8)(v>>16);
28387 SQLITE_PRIVATE u8 sqlite3HexToInt(
int h){
28388 assert( (h>=
'0' && h<=
'9') || (h>=
'a' && h<=
'f') || (h>=
'A' && h<=
'F') );
28389 #ifdef SQLITE_ASCII 28392 #ifdef SQLITE_EBCDIC 28393 h += 9*(1&~(h>>4));
28395 return (u8)(h & 0xf);
28398 #if !defined(SQLITE_OMIT_BLOB_LITERAL) || defined(SQLITE_HAS_CODEC) 28405 SQLITE_PRIVATE
void *sqlite3HexToBlob(
sqlite3 *db,
const char *z,
int n){
28409 zBlob = (
char *)sqlite3DbMallocRawNN(db, n/2 + 1);
28412 for(i=0; i<n; i+=2){
28413 zBlob[i/2] = (sqlite3HexToInt(z[i])<<4) | sqlite3HexToInt(z[i+1]);
28426 static void logBadConnection(
const char *zType){
28427 sqlite3_log(SQLITE_MISUSE,
28428 "API call with %s database connection pointer",
28447 SQLITE_PRIVATE
int sqlite3SafetyCheckOk(
sqlite3 *db){
28450 logBadConnection(
"NULL");
28454 if( magic!=SQLITE_MAGIC_OPEN ){
28455 if( sqlite3SafetyCheckSickOrOk(db) ){
28456 testcase( sqlite3GlobalConfig.xLog!=0 );
28457 logBadConnection(
"unopened");
28464 SQLITE_PRIVATE
int sqlite3SafetyCheckSickOrOk(
sqlite3 *db){
28467 if( magic!=SQLITE_MAGIC_SICK &&
28468 magic!=SQLITE_MAGIC_OPEN &&
28469 magic!=SQLITE_MAGIC_BUSY ){
28470 testcase( sqlite3GlobalConfig.xLog!=0 );
28471 logBadConnection(
"invalid");
28484 SQLITE_PRIVATE
int sqlite3AddInt64(i64 *pA, i64 iB){
28486 testcase( iA==0 ); testcase( iA==1 );
28487 testcase( iB==-1 ); testcase( iB==0 );
28489 testcase( iA>0 && LARGEST_INT64 - iA == iB );
28490 testcase( iA>0 && LARGEST_INT64 - iA == iB - 1 );
28491 if( iA>0 && LARGEST_INT64 - iA < iB )
return 1;
28493 testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 1 );
28494 testcase( iA<0 && -(iA + LARGEST_INT64) == iB + 2 );
28495 if( iA<0 && -(iA + LARGEST_INT64) > iB + 1 )
return 1;
28500 SQLITE_PRIVATE
int sqlite3SubInt64(i64 *pA, i64 iB){
28501 testcase( iB==SMALLEST_INT64+1 );
28502 if( iB==SMALLEST_INT64 ){
28503 testcase( (*pA)==(-1) ); testcase( (*pA)==0 );
28504 if( (*pA)>=0 )
return 1;
28508 return sqlite3AddInt64(pA, -iB);
28511 #define TWOPOWER32 (((i64)1)<<32) 28512 #define TWOPOWER31 (((i64)1)<<31) 28513 SQLITE_PRIVATE
int sqlite3MulInt64(i64 *pA, i64 iB){
28515 i64 iA1, iA0, iB1, iB0, r;
28517 iA1 = iA/TWOPOWER32;
28518 iA0 = iA % TWOPOWER32;
28519 iB1 = iB/TWOPOWER32;
28520 iB0 = iB % TWOPOWER32;
28527 }
else if( iB1==0 ){
28533 testcase( r==(-TWOPOWER31)-1 );
28534 testcase( r==(-TWOPOWER31) );
28535 testcase( r==TWOPOWER31 );
28536 testcase( r==TWOPOWER31-1 );
28537 if( r<(-TWOPOWER31) || r>=TWOPOWER31 )
return 1;
28539 if( sqlite3AddInt64(&r, iA0*iB0) )
return 1;
28548 SQLITE_PRIVATE
int sqlite3AbsInt32(
int x){
28549 if( x>=0 )
return x;
28550 if( x==(
int)0x80000000 )
return 0x7fffffff;
28554 #ifdef SQLITE_ENABLE_8_3_NAMES 28572 SQLITE_PRIVATE
void sqlite3FileSuffix3(
const char *zBaseFilename,
char *z){
28573 #if SQLITE_ENABLE_8_3_NAMES<2 28574 if( sqlite3_uri_boolean(zBaseFilename,
"8_3_names", 0) )
28578 sz = sqlite3Strlen30(z);
28579 for(i=sz-1; i>0 && z[i]!=
'/' && z[i]!=
'.'; i--){}
28580 if( z[i]==
'.' && ALWAYS(sz>i+4) ) memmove(&z[i+1], &z[sz-3], 4);
28591 SQLITE_PRIVATE LogEst sqlite3LogEstAdd(LogEst a, LogEst b){
28592 static const unsigned char x[] = {
28601 2, 2, 2, 2, 2, 2, 2,
28604 if( a>b+49 )
return a;
28605 if( a>b+31 )
return a+1;
28608 if( b>a+49 )
return b;
28609 if( b>a+31 )
return b+1;
28618 SQLITE_PRIVATE LogEst sqlite3LogEst(u64 x){
28619 static LogEst a[] = { 0, 2, 3, 5, 6, 7, 8, 9 };
28622 if( x<2 )
return 0;
28623 while( x<8 ){ y -= 10; x <<= 1; }
28625 while( x>255 ){ y += 40; x >>= 4; }
28626 while( x>15 ){ y += 10; x >>= 1; }
28628 return a[x&7] + y - 10;
28631 #ifndef SQLITE_OMIT_VIRTUALTABLE 28636 SQLITE_PRIVATE LogEst sqlite3LogEstFromDouble(
double x){
28639 assert(
sizeof(x)==8 &&
sizeof(a)==8 );
28640 if( x<=1 )
return 0;
28641 if( x<=2000000000 )
return sqlite3LogEst((u64)x);
28643 e = (a>>52) - 1022;
28648 #if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || \ 28649 defined(SQLITE_ENABLE_STAT3_OR_STAT4) || \ 28650 defined(SQLITE_EXPLAIN_ESTIMATED_ROWS) 28657 SQLITE_PRIVATE u64 sqlite3LogEstToInt(LogEst x){
28662 else if( n>=1 ) n -= 1;
28663 #if defined(SQLITE_ENABLE_STMT_SCANSTATUS) || \ 28664 defined(SQLITE_EXPLAIN_ESTIMATED_ROWS) 28665 if( x>60 )
return (u64)LARGEST_INT64;
28671 return x>=3 ? (n+8)<<(x-3) : (n+8)>>(3-x);
28699 SQLITE_PRIVATE
void sqlite3HashInit(Hash *pNew){
28711 SQLITE_PRIVATE
void sqlite3HashClear(Hash *pH){
28717 sqlite3_free(pH->ht);
28721 HashElem *next_elem = elem->next;
28722 sqlite3_free(elem);
28731 static unsigned int strHash(
const char *z){
28732 unsigned int h = 0;
28734 while( (c = (
unsigned char)*z++)!=0 ){
28735 h = (h<<3) ^ h ^ sqlite3UpperToLower[c];
28744 static void insertElement(
28746 struct _ht *pEntry,
28751 pHead = pEntry->count ? pEntry->chain : 0;
28753 pEntry->chain = pNew;
28758 pNew->next = pHead;
28759 pNew->prev = pHead->prev;
28760 if( pHead->prev ){ pHead->prev->next = pNew; }
28761 else { pH->first = pNew; }
28762 pHead->prev = pNew;
28764 pNew->next = pH->first;
28765 if( pH->first ){ pH->first->prev = pNew; }
28778 static int rehash(Hash *pH,
unsigned int new_size){
28779 struct _ht *new_ht;
28780 HashElem *elem, *next_elem;
28782 #if SQLITE_MALLOC_SOFT_LIMIT>0 28783 if( new_size*
sizeof(
struct _ht)>SQLITE_MALLOC_SOFT_LIMIT ){
28784 new_size = SQLITE_MALLOC_SOFT_LIMIT/
sizeof(
struct _ht);
28786 if( new_size==pH->htsize )
return 0;
28797 sqlite3BeginBenignMalloc();
28798 new_ht = (
struct _ht *)sqlite3Malloc( new_size*
sizeof(
struct _ht) );
28799 sqlite3EndBenignMalloc();
28801 if( new_ht==0 )
return 0;
28802 sqlite3_free(pH->ht);
28804 pH->htsize = new_size = sqlite3MallocSize(new_ht)/
sizeof(
struct _ht);
28805 memset(new_ht, 0, new_size*
sizeof(
struct _ht));
28806 for(elem=pH->first, pH->first=0; elem; elem = next_elem){
28807 unsigned int h = strHash(elem->pKey) % new_size;
28808 next_elem = elem->next;
28809 insertElement(pH, &new_ht[h], elem);
28818 static HashElem *findElementWithHash(
28821 unsigned int *pHash
28828 struct _ht *pEntry;
28829 h = strHash(pKey) % pH->htsize;
28830 pEntry = &pH->ht[h];
28831 elem = pEntry->chain;
28832 count = pEntry->count;
28841 if( sqlite3StrICmp(elem->pKey,pKey)==0 ){
28852 static void removeElementGivenHash(
28857 struct _ht *pEntry;
28859 elem->prev->next = elem->next;
28861 pH->first = elem->next;
28864 elem->next->prev = elem->prev;
28867 pEntry = &pH->ht[h];
28868 if( pEntry->chain==elem ){
28869 pEntry->chain = elem->next;
28872 assert( pEntry->count>=0 );
28874 sqlite3_free( elem );
28876 if( pH->count==0 ){
28877 assert( pH->first==0 );
28878 assert( pH->count==0 );
28879 sqlite3HashClear(pH);
28887 SQLITE_PRIVATE
void *sqlite3HashFind(
const Hash *pH,
const char *pKey){
28893 elem = findElementWithHash(pH, pKey, &h);
28894 return elem ? elem->data : 0;
28911 SQLITE_PRIVATE
void *sqlite3HashInsert(Hash *pH,
const char *pKey,
void *data){
28914 HashElem *new_elem;
28918 elem = findElementWithHash(pH,pKey,&h);
28920 void *old_data = elem->data;
28922 removeElementGivenHash(pH,elem,h);
28929 if( data==0 )
return 0;
28930 new_elem = (HashElem*)sqlite3Malloc(
sizeof(HashElem) );
28931 if( new_elem==0 )
return data;
28932 new_elem->pKey = pKey;
28933 new_elem->data = data;
28935 if( pH->count>=10 && pH->count > 2*pH->htsize ){
28936 if( rehash(pH, pH->count*2) ){
28937 assert( pH->htsize>0 );
28938 h = strHash(pKey) % pH->htsize;
28941 insertElement(pH, pH->ht ? &pH->ht[h] : 0, new_elem);
28949 #if !defined(SQLITE_OMIT_EXPLAIN) \ 28950 || defined(VDBE_PROFILE) \ 28951 || defined(SQLITE_DEBUG) 28952 #if defined(SQLITE_ENABLE_EXPLAIN_COMMENTS) || defined(SQLITE_DEBUG) 28953 # define OpHelp(X) "\0" X 28957 SQLITE_PRIVATE
const char *sqlite3OpcodeName(
int i){
28958 static const char *
const azName[] = {
28959 "Savepoint" OpHelp(
""),
28960 "AutoCommit" OpHelp(
""),
28961 "Transaction" OpHelp(
""),
28962 "SorterNext" OpHelp(
""),
28963 "PrevIfOpen" OpHelp(
""),
28964 "NextIfOpen" OpHelp(
""),
28967 "Checkpoint" OpHelp(
""),
28968 "JournalMode" OpHelp(
""),
28969 "Vacuum" OpHelp(
""),
28970 "VFilter" OpHelp(
"iplan=r[P3] zplan='P4'"),
28971 "VUpdate" OpHelp(
"data=r[P3@P2]"),
28973 "Gosub" OpHelp(
""),
28974 "InitCoroutine" OpHelp(
""),
28975 "Yield" OpHelp(
""),
28976 "MustBeInt" OpHelp(
""),
28978 "Not" OpHelp(
"r[P2]= !r[P1]"),
28981 "IfNot" OpHelp(
""),
28982 "SeekLT" OpHelp(
"key=r[P3@P4]"),
28983 "SeekLE" OpHelp(
"key=r[P3@P4]"),
28984 "SeekGE" OpHelp(
"key=r[P3@P4]"),
28985 "SeekGT" OpHelp(
"key=r[P3@P4]"),
28986 "Or" OpHelp(
"r[P3]=(r[P1] || r[P2])"),
28987 "And" OpHelp(
"r[P3]=(r[P1] && r[P2])"),
28988 "NoConflict" OpHelp(
"key=r[P3@P4]"),
28989 "NotFound" OpHelp(
"key=r[P3@P4]"),
28990 "Found" OpHelp(
"key=r[P3@P4]"),
28991 "SeekRowid" OpHelp(
"intkey=r[P3]"),
28992 "NotExists" OpHelp(
"intkey=r[P3]"),
28993 "IsNull" OpHelp(
"if r[P1]==NULL goto P2"),
28994 "NotNull" OpHelp(
"if r[P1]!=NULL goto P2"),
28995 "Ne" OpHelp(
"if r[P1]!=r[P3] goto P2"),
28996 "Eq" OpHelp(
"if r[P1]==r[P3] goto P2"),
28997 "Gt" OpHelp(
"if r[P1]>r[P3] goto P2"),
28998 "Le" OpHelp(
"if r[P1]<=r[P3] goto P2"),
28999 "Lt" OpHelp(
"if r[P1]<r[P3] goto P2"),
29000 "Ge" OpHelp(
"if r[P1]>=r[P3] goto P2"),
29002 "BitAnd" OpHelp(
"r[P3]=r[P1]&r[P2]"),
29003 "BitOr" OpHelp(
"r[P3]=r[P1]|r[P2]"),
29004 "ShiftLeft" OpHelp(
"r[P3]=r[P2]<<r[P1]"),
29005 "ShiftRight" OpHelp(
"r[P3]=r[P2]>>r[P1]"),
29006 "Add" OpHelp(
"r[P3]=r[P1]+r[P2]"),
29007 "Subtract" OpHelp(
"r[P3]=r[P2]-r[P1]"),
29008 "Multiply" OpHelp(
"r[P3]=r[P1]*r[P2]"),
29009 "Divide" OpHelp(
"r[P3]=r[P2]/r[P1]"),
29010 "Remainder" OpHelp(
"r[P3]=r[P2]%r[P1]"),
29011 "Concat" OpHelp(
"r[P3]=r[P2]+r[P1]"),
29012 "SorterSort" OpHelp(
""),
29013 "BitNot" OpHelp(
"r[P1]= ~r[P1]"),
29015 "Rewind" OpHelp(
""),
29016 "IdxLE" OpHelp(
"key=r[P3@P4]"),
29017 "IdxGT" OpHelp(
"key=r[P3@P4]"),
29018 "IdxLT" OpHelp(
"key=r[P3@P4]"),
29019 "IdxGE" OpHelp(
"key=r[P3@P4]"),
29020 "RowSetRead" OpHelp(
"r[P3]=rowset(P1)"),
29021 "RowSetTest" OpHelp(
"if r[P3] in rowset(P1) goto P2"),
29022 "Program" OpHelp(
""),
29023 "FkIfZero" OpHelp(
"if fkctr[P1]==0 goto P2"),
29024 "IfPos" OpHelp(
"if r[P1]>0 then r[P1]-=P3, goto P2"),
29025 "IfNotZero" OpHelp(
"if r[P1]!=0 then r[P1]-=P3, goto P2"),
29026 "DecrJumpZero" OpHelp(
"if (--r[P1])==0 goto P2"),
29027 "IncrVacuum" OpHelp(
""),
29028 "VNext" OpHelp(
""),
29029 "Init" OpHelp(
"Start at P2"),
29030 "Return" OpHelp(
""),
29031 "EndCoroutine" OpHelp(
""),
29032 "HaltIfNull" OpHelp(
"if r[P3]=null halt"),
29034 "Integer" OpHelp(
"r[P2]=P1"),
29035 "Int64" OpHelp(
"r[P2]=P4"),
29036 "String" OpHelp(
"r[P2]='P4' (len=P1)"),
29037 "Null" OpHelp(
"r[P2..P3]=NULL"),
29038 "SoftNull" OpHelp(
"r[P1]=NULL"),
29039 "Blob" OpHelp(
"r[P2]=P4 (len=P1)"),
29040 "Variable" OpHelp(
"r[P2]=parameter(P1,P4)"),
29041 "Move" OpHelp(
"r[P2@P3]=r[P1@P3]"),
29042 "Copy" OpHelp(
"r[P2@P3+1]=r[P1@P3+1]"),
29043 "SCopy" OpHelp(
"r[P2]=r[P1]"),
29044 "IntCopy" OpHelp(
"r[P2]=r[P1]"),
29045 "ResultRow" OpHelp(
"output=r[P1@P2]"),
29046 "CollSeq" OpHelp(
""),
29047 "Function0" OpHelp(
"r[P3]=func(r[P2@P5])"),
29048 "Function" OpHelp(
"r[P3]=func(r[P2@P5])"),
29049 "AddImm" OpHelp(
"r[P1]=r[P1]+P2"),
29050 "RealAffinity" OpHelp(
""),
29051 "Cast" OpHelp(
"affinity(r[P1])"),
29052 "Permutation" OpHelp(
""),
29053 "Compare" OpHelp(
"r[P1@P3] <-> r[P2@P3]"),
29054 "Column" OpHelp(
"r[P3]=PX"),
29055 "Affinity" OpHelp(
"affinity(r[P1@P2])"),
29056 "String8" OpHelp(
"r[P2]='P4'"),
29057 "MakeRecord" OpHelp(
"r[P3]=mkrec(r[P1@P2])"),
29058 "Count" OpHelp(
"r[P2]=count()"),
29059 "ReadCookie" OpHelp(
""),
29060 "SetCookie" OpHelp(
""),
29061 "ReopenIdx" OpHelp(
"root=P2 iDb=P3"),
29062 "OpenRead" OpHelp(
"root=P2 iDb=P3"),
29063 "OpenWrite" OpHelp(
"root=P2 iDb=P3"),
29064 "OpenAutoindex" OpHelp(
"nColumn=P2"),
29065 "OpenEphemeral" OpHelp(
"nColumn=P2"),
29066 "SorterOpen" OpHelp(
""),
29067 "SequenceTest" OpHelp(
"if( cursor[P1].ctr++ ) pc = P2"),
29068 "OpenPseudo" OpHelp(
"P3 columns in r[P2]"),
29069 "Close" OpHelp(
""),
29070 "ColumnsUsed" OpHelp(
""),
29071 "Sequence" OpHelp(
"r[P2]=cursor[P1].ctr++"),
29072 "NewRowid" OpHelp(
"r[P2]=rowid"),
29073 "Insert" OpHelp(
"intkey=r[P3] data=r[P2]"),
29074 "InsertInt" OpHelp(
"intkey=P3 data=r[P2]"),
29075 "Delete" OpHelp(
""),
29076 "ResetCount" OpHelp(
""),
29077 "SorterCompare" OpHelp(
"if key(P1)!=trim(r[P3],P4) goto P2"),
29078 "SorterData" OpHelp(
"r[P2]=data"),
29079 "RowKey" OpHelp(
"r[P2]=key"),
29080 "RowData" OpHelp(
"r[P2]=data"),
29081 "Rowid" OpHelp(
"r[P2]=rowid"),
29082 "NullRow" OpHelp(
""),
29083 "SorterInsert" OpHelp(
""),
29084 "IdxInsert" OpHelp(
"key=r[P2]"),
29085 "IdxDelete" OpHelp(
"key=r[P2@P3]"),
29086 "Seek" OpHelp(
"Move P3 to P1.rowid"),
29087 "IdxRowid" OpHelp(
"r[P2]=rowid"),
29088 "Destroy" OpHelp(
""),
29089 "Clear" OpHelp(
""),
29090 "ResetSorter" OpHelp(
""),
29091 "CreateIndex" OpHelp(
"r[P2]=root iDb=P1"),
29092 "Real" OpHelp(
"r[P2]=P4"),
29093 "CreateTable" OpHelp(
"r[P2]=root iDb=P1"),
29094 "ParseSchema" OpHelp(
""),
29095 "LoadAnalysis" OpHelp(
""),
29096 "DropTable" OpHelp(
""),
29097 "DropIndex" OpHelp(
""),
29098 "DropTrigger" OpHelp(
""),
29099 "IntegrityCk" OpHelp(
""),
29100 "RowSetAdd" OpHelp(
"rowset(P1)=r[P2]"),
29101 "Param" OpHelp(
""),
29102 "FkCounter" OpHelp(
"fkctr[P1]+=P2"),
29103 "MemMax" OpHelp(
"r[P1]=max(r[P1],r[P2])"),
29104 "OffsetLimit" OpHelp(
"if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1)"),
29105 "AggStep0" OpHelp(
"accum=r[P3] step(r[P2@P5])"),
29106 "AggStep" OpHelp(
"accum=r[P3] step(r[P2@P5])"),
29107 "AggFinal" OpHelp(
"accum=r[P1] N=P2"),
29108 "Expire" OpHelp(
""),
29109 "TableLock" OpHelp(
"iDb=P1 root=P2 write=P3"),
29110 "VBegin" OpHelp(
""),
29111 "VCreate" OpHelp(
""),
29112 "VDestroy" OpHelp(
""),
29113 "VOpen" OpHelp(
""),
29114 "VColumn" OpHelp(
"r[P3]=vcolumn(P2)"),
29115 "VRename" OpHelp(
""),
29116 "Pagecount" OpHelp(
""),
29117 "MaxPgcnt" OpHelp(
""),
29118 "CursorHint" OpHelp(
""),
29120 "Explain" OpHelp(
""),
29193 #if !defined(SQLITE_ENABLE_LOCKING_STYLE) 29194 # if defined(__APPLE__) 29195 # define SQLITE_ENABLE_LOCKING_STYLE 1 29197 # define SQLITE_ENABLE_LOCKING_STYLE 0 29202 #if defined(__APPLE__) 29203 # define HAVE_PREAD 1 29204 # define HAVE_PWRITE 1 29206 #if defined(HAVE_PREAD64) && defined(HAVE_PWRITE64) 29208 # define USE_PREAD64 1 29209 #elif defined(HAVE_PREAD) && defined(HAVE_PWRITE) 29210 # undef USE_PREAD64 29211 # define USE_PREAD 1 29217 #include <sys/types.h> 29218 #include <sys/stat.h> 29220 #include <unistd.h> 29222 #include <sys/time.h> 29224 #if !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0 29225 # include <sys/mman.h> 29228 #if SQLITE_ENABLE_LOCKING_STYLE 29229 # include <sys/ioctl.h> 29230 # include <sys/file.h> 29231 # include <sys/param.h> 29234 #if defined(__APPLE__) && ((__MAC_OS_X_VERSION_MIN_REQUIRED > 1050) || \ 29235 (__IPHONE_OS_VERSION_MIN_REQUIRED > 2000)) 29236 # if (!defined(TARGET_OS_EMBEDDED) || (TARGET_OS_EMBEDDED==0)) \ 29237 && (!defined(TARGET_IPHONE_SIMULATOR) || (TARGET_IPHONE_SIMULATOR==0)) 29238 # define HAVE_GETHOSTUUID 1 29240 # warning "gethostuuid() is disabled." 29247 # include <semaphore.h> 29248 # include <limits.h> 29251 #if defined(__APPLE__) || SQLITE_ENABLE_LOCKING_STYLE 29252 # include <sys/mount.h> 29256 # include <utime.h> 29262 #define SQLITE_FSFLAGS_IS_MSDOS 0x1 29268 #if SQLITE_THREADSAFE 29270 # define SQLITE_UNIX_THREADS 1 29276 #ifndef SQLITE_DEFAULT_FILE_PERMISSIONS 29277 # define SQLITE_DEFAULT_FILE_PERMISSIONS 0644 29283 #ifndef SQLITE_DEFAULT_PROXYDIR_PERMISSIONS 29284 # define SQLITE_DEFAULT_PROXYDIR_PERMISSIONS 0755 29290 #define MAX_PATHNAME 512 29295 #define SQLITE_MAX_SYMLINKS 100 29299 #define osGetpid(X) (pid_t)getpid() 29305 #define IS_LOCK_ERROR(x) ((x != SQLITE_OK) && (x != SQLITE_BUSY)) 29308 typedef struct unixShm unixShm;
29319 struct UnixUnusedFd {
29322 UnixUnusedFd *pNext;
29333 unixInodeInfo *pInode;
29335 unsigned char eFileLock;
29336 unsigned short int ctrlFlags;
29338 void *lockingContext;
29339 UnixUnusedFd *pUnused;
29343 #if SQLITE_MAX_MMAP_SIZE>0 29345 sqlite3_int64 mmapSize;
29346 sqlite3_int64 mmapSizeActual;
29347 sqlite3_int64 mmapSizeMax;
29352 int deviceCharacteristics;
29354 #if SQLITE_ENABLE_LOCKING_STYLE 29357 #if SQLITE_ENABLE_LOCKING_STYLE || defined(__APPLE__) 29363 #ifdef SQLITE_DEBUG 29371 unsigned char transCntrChng;
29372 unsigned char dbUpdate;
29373 unsigned char inNormalWrite;
29389 static pid_t randomnessPid = 0;
29394 #define UNIXFILE_EXCL 0x01 29395 #define UNIXFILE_RDONLY 0x02 29396 #define UNIXFILE_PERSIST_WAL 0x04 29397 #ifndef SQLITE_DISABLE_DIRSYNC 29398 # define UNIXFILE_DIRSYNC 0x08 29400 # define UNIXFILE_DIRSYNC 0x00 29402 #define UNIXFILE_PSOW 0x10 29403 #define UNIXFILE_DELETE 0x20 29404 #define UNIXFILE_URI 0x40 29405 #define UNIXFILE_NOLOCK 0x80 29431 #ifndef _OS_COMMON_H_ 29432 #define _OS_COMMON_H_ 29439 #ifdef MEMORY_DEBUG 29440 # error "The MEMORY_DEBUG macro is obsolete. Use SQLITE_DEBUG instead." 29447 #ifdef SQLITE_PERFORMANCE_TRACE 29470 #ifndef SQLITE_HWTIME_H 29471 #define SQLITE_HWTIME_H 29479 #if (defined(__GNUC__) || defined(_MSC_VER)) && \ 29480 (defined(i386) || defined(__i386__) || defined(_M_IX86)) 29482 #if defined(__GNUC__) 29484 __inline__ sqlite_uint64 sqlite3Hwtime(
void){
29485 unsigned int lo, hi;
29486 __asm__ __volatile__ (
"rdtsc" :
"=a" (lo),
"=d" (hi));
29487 return (sqlite_uint64)hi << 32 | lo;
29490 #elif defined(_MSC_VER) 29492 __declspec(naked) __inline sqlite_uint64 __cdecl sqlite3Hwtime(
void){
29495 ret ;
return value at EDX:EAX
29501 #elif (defined(__GNUC__) && defined(__x86_64__)) 29503 __inline__ sqlite_uint64 sqlite3Hwtime(
void){
29505 __asm__ __volatile__ (
"rdtsc" :
"=A" (val));
29509 #elif (defined(__GNUC__) && defined(__ppc__)) 29511 __inline__ sqlite_uint64 sqlite3Hwtime(
void){
29512 unsigned long long retval;
29513 unsigned long junk;
29514 __asm__ __volatile__ (
"\n\ 29520 :
"=r" (retval),
"=r" (junk));
29526 #error Need implementation of sqlite3Hwtime() for your platform. 29535 SQLITE_PRIVATE sqlite_uint64 sqlite3Hwtime(
void){
return ((sqlite_uint64)0); }
29544 static sqlite_uint64 g_start;
29545 static sqlite_uint64 g_elapsed;
29546 #define TIMER_START g_start=sqlite3Hwtime() 29547 #define TIMER_END g_elapsed=sqlite3Hwtime()-g_start 29548 #define TIMER_ELAPSED g_elapsed 29550 #define TIMER_START 29552 #define TIMER_ELAPSED ((sqlite_uint64)0) 29560 #if defined(SQLITE_TEST) 29561 SQLITE_API
extern int sqlite3_io_error_hit;
29562 SQLITE_API
extern int sqlite3_io_error_hardhit;
29563 SQLITE_API
extern int sqlite3_io_error_pending;
29564 SQLITE_API
extern int sqlite3_io_error_persist;
29565 SQLITE_API
extern int sqlite3_io_error_benign;
29566 SQLITE_API
extern int sqlite3_diskfull_pending;
29567 SQLITE_API
extern int sqlite3_diskfull;
29568 #define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X) 29569 #define SimulateIOError(CODE) \ 29570 if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \ 29571 || sqlite3_io_error_pending-- == 1 ) \ 29572 { local_ioerr(); CODE; } 29573 static void local_ioerr(){
29574 IOTRACE((
"IOERR\n"));
29575 sqlite3_io_error_hit++;
29576 if( !sqlite3_io_error_benign ) sqlite3_io_error_hardhit++;
29578 #define SimulateDiskfullError(CODE) \ 29579 if( sqlite3_diskfull_pending ){ \ 29580 if( sqlite3_diskfull_pending == 1 ){ \ 29582 sqlite3_diskfull = 1; \ 29583 sqlite3_io_error_hit = 1; \ 29586 sqlite3_diskfull_pending--; \ 29590 #define SimulateIOErrorBenign(X) 29591 #define SimulateIOError(A) 29592 #define SimulateDiskfullError(A) 29598 #if defined(SQLITE_TEST) 29599 SQLITE_API
extern int sqlite3_open_file_count;
29600 #define OpenCounter(X) sqlite3_open_file_count+=(X) 29602 #define OpenCounter(X) 29613 #ifndef O_LARGEFILE 29614 # define O_LARGEFILE 0 29616 #ifdef SQLITE_DISABLE_LFS 29617 # undef O_LARGEFILE 29618 # define O_LARGEFILE 0 29621 # define O_NOFOLLOW 0 29624 # define O_BINARY 0 29631 #if SQLITE_THREADSAFE 29632 #define threadid pthread_self() 29640 #if !defined(HAVE_MREMAP) 29641 # if defined(__linux__) && defined(_GNU_SOURCE) 29642 # define HAVE_MREMAP 1 29644 # define HAVE_MREMAP 0 29653 # define lseek lseek64 29664 static int posixOpen(
const char *zFile,
int flags,
int mode){
29665 return open(zFile, flags, mode);
29669 static int openDirectory(
const char*,
int*);
29670 static int unixGetpagesize(
void);
29678 static struct unix_syscall {
29680 sqlite3_syscall_ptr pCurrent;
29681 sqlite3_syscall_ptr pDefault;
29683 {
"open", (sqlite3_syscall_ptr)posixOpen, 0 },
29684 #define osOpen ((
int(*)(
const char*,
int,
int))aSyscall[0].pCurrent)
29686 {
"close", (sqlite3_syscall_ptr)close, 0 },
29687 #define osClose ((
int(*)(int))aSyscall[1].pCurrent)
29689 {
"access", (sqlite3_syscall_ptr)access, 0 },
29690 #define osAccess ((
int(*)(
const char*,int))aSyscall[2].pCurrent)
29692 {
"getcwd", (sqlite3_syscall_ptr)getcwd, 0 },
29693 #define osGetcwd ((
char*(*)(
char*,size_t))aSyscall[3].pCurrent)
29695 {
"stat", (sqlite3_syscall_ptr)stat, 0 },
29696 #define osStat ((
int(*)(
const char*,
struct stat*))aSyscall[4].pCurrent)
29706 #define osFstat(a,b,c) 0 29708 {
"fstat", (sqlite3_syscall_ptr)fstat, 0 },
29709 #define osFstat ((
int(*)(int,
struct stat*))aSyscall[5].pCurrent)
29712 {
"ftruncate", (sqlite3_syscall_ptr)ftruncate, 0 },
29713 #define osFtruncate ((
int(*)(int,off_t))aSyscall[6].pCurrent)
29715 {
"fcntl", (sqlite3_syscall_ptr)fcntl, 0 },
29716 #define osFcntl ((
int(*)(int,int,...))aSyscall[7].pCurrent)
29718 {
"read", (sqlite3_syscall_ptr)read, 0 },
29719 #define osRead ((ssize_t(*)(int,
void*,size_t))aSyscall[8].pCurrent)
29721 #
if defined(USE_PREAD) || SQLITE_ENABLE_LOCKING_STYLE
29722 {
"pread", (sqlite3_syscall_ptr)pread, 0 },
29724 {
"pread", (sqlite3_syscall_ptr)0, 0 },
29726 #define osPread ((ssize_t(*)(int,
void*,size_t,off_t))aSyscall[9].pCurrent)
29728 #
if defined(USE_PREAD64)
29729 {
"pread64", (sqlite3_syscall_ptr)pread64, 0 },
29731 {
"pread64", (sqlite3_syscall_ptr)0, 0 },
29733 #define osPread64 ((ssize_t(*)(int,
void*,size_t,off64_t))aSyscall[10].pCurrent)
29735 {
"write", (sqlite3_syscall_ptr)write, 0 },
29736 #define osWrite ((ssize_t(*)(int,
const void*,size_t))aSyscall[11].pCurrent)
29738 #
if defined(USE_PREAD) || SQLITE_ENABLE_LOCKING_STYLE
29739 {
"pwrite", (sqlite3_syscall_ptr)pwrite, 0 },
29741 {
"pwrite", (sqlite3_syscall_ptr)0, 0 },
29743 #define osPwrite ((ssize_t(*)(int,
const void*,size_t,off_t))\
29744 aSyscall[12].pCurrent)
29746 #
if defined(USE_PREAD64)
29747 {
"pwrite64", (sqlite3_syscall_ptr)pwrite64, 0 },
29749 {
"pwrite64", (sqlite3_syscall_ptr)0, 0 },
29751 #define osPwrite64 ((ssize_t(*)(int,
const void*,size_t,off64_t))\
29752 aSyscall[13].pCurrent)
29754 {
"fchmod", (sqlite3_syscall_ptr)fchmod, 0 },
29755 #define osFchmod ((
int(*)(int,mode_t))aSyscall[14].pCurrent)
29757 #
if defined(HAVE_POSIX_FALLOCATE) && HAVE_POSIX_FALLOCATE
29758 {
"fallocate", (sqlite3_syscall_ptr)posix_fallocate, 0 },
29760 {
"fallocate", (sqlite3_syscall_ptr)0, 0 },
29762 #define osFallocate ((
int(*)(int,off_t,off_t))aSyscall[15].pCurrent)
29764 {
"unlink", (sqlite3_syscall_ptr)unlink, 0 },
29765 #define osUnlink ((
int(*)(
const char*))aSyscall[16].pCurrent)
29767 {
"openDirectory", (sqlite3_syscall_ptr)openDirectory, 0 },
29768 #define osOpenDirectory ((
int(*)(
const char*,
int*))aSyscall[17].pCurrent)
29770 {
"mkdir", (sqlite3_syscall_ptr)mkdir, 0 },
29771 #define osMkdir ((
int(*)(
const char*,mode_t))aSyscall[18].pCurrent)
29773 {
"rmdir", (sqlite3_syscall_ptr)rmdir, 0 },
29774 #define osRmdir ((
int(*)(
const char*))aSyscall[19].pCurrent)
29776 #
if defined(HAVE_FCHOWN)
29777 {
"fchown", (sqlite3_syscall_ptr)fchown, 0 },
29779 {
"fchown", (sqlite3_syscall_ptr)0, 0 },
29781 #define osFchown ((
int(*)(int,uid_t,gid_t))aSyscall[20].pCurrent)
29783 {
"geteuid", (sqlite3_syscall_ptr)geteuid, 0 },
29784 #define osGeteuid ((uid_t(*)(void))aSyscall[21].pCurrent)
29786 #
if !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0
29787 {
"mmap", (sqlite3_syscall_ptr)mmap, 0 },
29789 {
"mmap", (sqlite3_syscall_ptr)0, 0 },
29791 #define osMmap ((
void*(*)(
void*,size_t,int,int,int,off_t))aSyscall[22].pCurrent)
29793 #
if !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0
29794 {
"munmap", (sqlite3_syscall_ptr)munmap, 0 },
29796 {
"munmap", (sqlite3_syscall_ptr)0, 0 },
29798 #define osMunmap ((
void*(*)(
void*,size_t))aSyscall[23].pCurrent)
29800 #
if HAVE_MREMAP && (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0)
29801 {
"mremap", (sqlite3_syscall_ptr)mremap, 0 },
29803 {
"mremap", (sqlite3_syscall_ptr)0, 0 },
29805 #define osMremap ((
void*(*)(
void*,size_t,size_t,int,...))aSyscall[24].pCurrent)
29807 #if !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0 29808 {
"getpagesize", (sqlite3_syscall_ptr)unixGetpagesize, 0 },
29810 {
"getpagesize", (sqlite3_syscall_ptr)0, 0 },
29812 #define osGetpagesize ((
int(*)(void))aSyscall[25].pCurrent)
29814 #
if defined(HAVE_READLINK)
29815 {
"readlink", (sqlite3_syscall_ptr)readlink, 0 },
29817 {
"readlink", (sqlite3_syscall_ptr)0, 0 },
29819 #define osReadlink ((ssize_t(*)(
const char*,
char*,size_t))aSyscall[26].pCurrent)
29821 #
if defined(HAVE_LSTAT)
29822 {
"lstat", (sqlite3_syscall_ptr)lstat, 0 },
29824 {
"lstat", (sqlite3_syscall_ptr)0, 0 },
29826 #define osLstat ((
int(*)(
const char*,
struct stat*))aSyscall[27].pCurrent)
29836 static int robustFchown(
int fd, uid_t uid, gid_t gid){
29837 #if defined(HAVE_FCHOWN) 29838 return osGeteuid() ? 0 : osFchown(fd,uid,gid);
29850 static int unixSetSystemCall(
29853 sqlite3_syscall_ptr pNewFunc
29856 int rc = SQLITE_NOTFOUND;
29858 UNUSED_PARAMETER(pNotUsed);
29864 for(i=0; i<
sizeof(aSyscall)/
sizeof(aSyscall[0]); i++){
29865 if( aSyscall[i].pDefault ){
29866 aSyscall[i].pCurrent = aSyscall[i].pDefault;
29873 for(i=0; i<
sizeof(aSyscall)/
sizeof(aSyscall[0]); i++){
29874 if( strcmp(zName, aSyscall[i].zName)==0 ){
29875 if( aSyscall[i].pDefault==0 ){
29876 aSyscall[i].pDefault = aSyscall[i].pCurrent;
29879 if( pNewFunc==0 ) pNewFunc = aSyscall[i].pDefault;
29880 aSyscall[i].pCurrent = pNewFunc;
29893 static sqlite3_syscall_ptr unixGetSystemCall(
29899 UNUSED_PARAMETER(pNotUsed);
29900 for(i=0; i<
sizeof(aSyscall)/
sizeof(aSyscall[0]); i++){
29901 if( strcmp(zName, aSyscall[i].zName)==0 )
return aSyscall[i].pCurrent;
29912 static const char *unixNextSystemCall(
sqlite3_vfs *p,
const char *zName){
29915 UNUSED_PARAMETER(p);
29917 for(i=0; i<ArraySize(aSyscall)-1; i++){
29918 if( strcmp(zName, aSyscall[i].zName)==0 )
break;
29921 for(i++; i<ArraySize(aSyscall); i++){
29922 if( aSyscall[i].pCurrent!=0 )
return aSyscall[i].zName;
29932 #ifndef SQLITE_MINIMUM_FILE_DESCRIPTOR 29933 # define SQLITE_MINIMUM_FILE_DESCRIPTOR 3 29953 static int robust_open(
const char *z,
int f, mode_t m){
29955 mode_t m2 = m ? m : SQLITE_DEFAULT_FILE_PERMISSIONS;
29957 #if defined(O_CLOEXEC) 29958 fd = osOpen(z,f|O_CLOEXEC,m2);
29960 fd = osOpen(z,f,m2);
29963 if( errno==EINTR )
continue;
29966 if( fd>=SQLITE_MINIMUM_FILE_DESCRIPTOR )
break;
29968 sqlite3_log(SQLITE_WARNING,
29969 "attempt to open \"%s\" as file descriptor %d", z, fd);
29971 if( osOpen(
"/dev/null", f, m)<0 )
break;
29975 struct stat statbuf;
29976 if( osFstat(fd, &statbuf)==0
29977 && statbuf.st_size==0
29978 && (statbuf.st_mode&0777)!=m
29983 #if defined(FD_CLOEXEC) && (!defined(O_CLOEXEC) || O_CLOEXEC==0) 29984 osFcntl(fd, F_SETFD, osFcntl(fd, F_GETFD, 0) | FD_CLOEXEC);
30004 static void unixEnterMutex(
void){
30005 sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1));
30007 static void unixLeaveMutex(
void){
30008 sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1));
30010 #ifdef SQLITE_DEBUG 30011 static int unixMutexHeld(
void) {
30012 return sqlite3_mutex_held(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_VFS1));
30017 #ifdef SQLITE_HAVE_OS_TRACE 30023 static const char *azFileLock(
int eFileLock){
30024 switch( eFileLock ){
30025 case NO_LOCK:
return "NONE";
30026 case SHARED_LOCK:
return "SHARED";
30027 case RESERVED_LOCK:
return "RESERVED";
30028 case PENDING_LOCK:
return "PENDING";
30029 case EXCLUSIVE_LOCK:
return "EXCLUSIVE";
30035 #ifdef SQLITE_LOCK_TRACE 30044 static int lockTrace(
int fd,
int op,
struct flock *p){
30045 char *zOpName, *zType;
30050 }
else if( op==F_SETLK ){
30053 s = osFcntl(fd, op, p);
30054 sqlite3DebugPrintf(
"fcntl unknown %d %d %d\n", fd, op, s);
30057 if( p->l_type==F_RDLCK ){
30059 }
else if( p->l_type==F_WRLCK ){
30061 }
else if( p->l_type==F_UNLCK ){
30066 assert( p->l_whence==SEEK_SET );
30067 s = osFcntl(fd, op, p);
30068 savedErrno = errno;
30069 sqlite3DebugPrintf(
"fcntl %d %d %s %s %d %d %d %d\n",
30070 threadid, fd, zOpName, zType, (
int)p->l_start, (
int)p->l_len,
30072 if( s==(-1) && op==F_SETLK && (p->l_type==F_RDLCK || p->l_type==F_WRLCK) ){
30075 osFcntl(fd, F_GETLK, &l2);
30076 if( l2.l_type==F_RDLCK ){
30078 }
else if( l2.l_type==F_WRLCK ){
30080 }
else if( l2.l_type==F_UNLCK ){
30085 sqlite3DebugPrintf(
"fcntl-failure-reason: %s %d %d %d\n",
30086 zType, (
int)l2.l_start, (
int)l2.l_len, (
int)l2.l_pid);
30088 errno = savedErrno;
30092 #define osFcntl lockTrace 30102 static int robust_ftruncate(
int h, sqlite3_int64 sz){
30109 if( sz>(sqlite3_int64)0x7FFFFFFF ){
30113 do{ rc = osFtruncate(h,sz); }
while( rc<0 && errno==EINTR );
30127 static int sqliteErrorFromPosixError(
int posixError,
int sqliteIOErr) {
30128 assert( (sqliteIOErr == SQLITE_IOERR_LOCK) ||
30129 (sqliteIOErr == SQLITE_IOERR_UNLOCK) ||
30130 (sqliteIOErr == SQLITE_IOERR_RDLOCK) ||
30131 (sqliteIOErr == SQLITE_IOERR_CHECKRESERVEDLOCK) );
30132 switch (posixError) {
30141 return SQLITE_BUSY;
30144 return SQLITE_PERM;
30147 return sqliteIOErr;
30173 char *zCanonicalName;
30196 static int vxworksSimplifyName(
char *z,
int n){
30198 while( n>1 && z[n-1]==
'/' ){ n--; }
30199 for(i=j=0; i<n; i++){
30201 if( z[i+1]==
'/' )
continue;
30202 if( z[i+1]==
'.' && i+2<n && z[i+2]==
'/' ){
30206 if( z[i+1]==
'.' && i+3<n && z[i+2]==
'.' && z[i+3]==
'/' ){
30207 while( j>0 && z[j-1]!=
'/' ){ j--; }
30230 static struct vxworksFileId *vxworksFindFileId(
const char *zAbsoluteName){
30235 assert( zAbsoluteName[0]==
'/' );
30236 n = (int)strlen(zAbsoluteName);
30237 pNew = sqlite3_malloc64(
sizeof(*pNew) + (n+1) );
30238 if( pNew==0 )
return 0;
30239 pNew->zCanonicalName = (
char*)&pNew[1];
30240 memcpy(pNew->zCanonicalName, zAbsoluteName, n+1);
30241 n = vxworksSimplifyName(pNew->zCanonicalName, n);
30248 for(pCandidate=vxworksFileList; pCandidate; pCandidate=pCandidate->pNext){
30249 if( pCandidate->nName==n
30250 && memcmp(pCandidate->zCanonicalName, pNew->zCanonicalName, n)==0
30252 sqlite3_free(pNew);
30253 pCandidate->nRef++;
30262 pNew->pNext = vxworksFileList;
30263 vxworksFileList = pNew;
30272 static void vxworksReleaseFileId(
struct vxworksFileId *pId){
30274 assert( pId->nRef>0 );
30276 if( pId->nRef==0 ){
30278 for(pp=&vxworksFileList; *pp && *pp!=pId; pp = &((*pp)->pNext)){}
30279 assert( *pp==pId );
30402 struct unixInodeInfo {
30405 unsigned char eFileLock;
30406 unsigned char bProcessLock;
30408 unixShmNode *pShmNode;
30410 UnixUnusedFd *pUnused;
30411 unixInodeInfo *pNext;
30412 unixInodeInfo *pPrev;
30413 #if SQLITE_ENABLE_LOCKING_STYLE 30414 unsigned long long sharedByte;
30418 char aSemName[MAX_PATHNAME+2];
30425 static unixInodeInfo *inodeList = 0;
30443 #define unixLogError(a,b,c) unixLogErrorAtLine(a,b,c,__LINE__) 30444 static int unixLogErrorAtLine(
30451 int iErrno = errno;
30457 #if SQLITE_THREADSAFE && defined(HAVE_STRERROR_R) 30459 memset(aErr, 0,
sizeof(aErr));
30474 #if defined(STRERROR_R_CHAR_P) || defined(__USE_GNU) 30477 strerror_r(iErrno, aErr,
sizeof(aErr)-1);
30479 #elif SQLITE_THREADSAFE 30484 zErr = strerror(iErrno);
30487 if( zPath==0 ) zPath =
"";
30488 sqlite3_log(errcode,
30489 "os_unix.c:%d: (%d) %s(%s) - %s",
30490 iLine, iErrno, zFunc, zPath, zErr
30509 static void robust_close(unixFile *pFile,
int h,
int lineno){
30511 unixLogErrorAtLine(SQLITE_IOERR_CLOSE,
"close",
30512 pFile ? pFile->zPath : 0, lineno);
30520 static void storeLastErrno(unixFile *pFile,
int error){
30521 pFile->lastErrno = error;
30527 static void closePendingFds(unixFile *pFile){
30528 unixInodeInfo *pInode = pFile->pInode;
30530 UnixUnusedFd *pNext;
30531 for(p=pInode->pUnused; p; p=pNext){
30533 robust_close(pFile, p->fd, __LINE__);
30536 pInode->pUnused = 0;
30545 static void releaseInodeInfo(unixFile *pFile){
30546 unixInodeInfo *pInode = pFile->pInode;
30547 assert( unixMutexHeld() );
30548 if( ALWAYS(pInode) ){
30550 if( pInode->nRef==0 ){
30551 assert( pInode->pShmNode==0 );
30552 closePendingFds(pFile);
30553 if( pInode->pPrev ){
30554 assert( pInode->pPrev->pNext==pInode );
30555 pInode->pPrev->pNext = pInode->pNext;
30557 assert( inodeList==pInode );
30558 inodeList = pInode->pNext;
30560 if( pInode->pNext ){
30561 assert( pInode->pNext->pPrev==pInode );
30562 pInode->pNext->pPrev = pInode->pPrev;
30564 sqlite3_free(pInode);
30579 static int findInodeInfo(
30581 unixInodeInfo **ppInode
30586 struct stat statbuf;
30587 unixInodeInfo *pInode = 0;
30589 assert( unixMutexHeld() );
30595 rc = osFstat(fd, &statbuf);
30597 storeLastErrno(pFile, errno);
30598 #if defined(EOVERFLOW) && defined(SQLITE_DISABLE_LFS) 30599 if( pFile->lastErrno==EOVERFLOW )
return SQLITE_NOLFS;
30601 return SQLITE_IOERR;
30615 if( statbuf.st_size==0 && (pFile->fsFlags & SQLITE_FSFLAGS_IS_MSDOS)!=0 ){
30616 do{ rc = osWrite(fd,
"S", 1); }
while( rc<0 && errno==EINTR );
30618 storeLastErrno(pFile, errno);
30619 return SQLITE_IOERR;
30621 rc = osFstat(fd, &statbuf);
30623 storeLastErrno(pFile, errno);
30624 return SQLITE_IOERR;
30629 memset(&fileId, 0,
sizeof(fileId));
30630 fileId.dev = statbuf.st_dev;
30632 fileId.pId = pFile->pId;
30634 fileId.ino = statbuf.st_ino;
30636 pInode = inodeList;
30637 while( pInode && memcmp(&fileId, &pInode->fileId,
sizeof(fileId)) ){
30638 pInode = pInode->pNext;
30641 pInode = sqlite3_malloc64(
sizeof(*pInode) );
30643 return SQLITE_NOMEM_BKPT;
30645 memset(pInode, 0,
sizeof(*pInode));
30646 memcpy(&pInode->fileId, &fileId,
sizeof(fileId));
30648 pInode->pNext = inodeList;
30650 if( inodeList ) inodeList->pPrev = pInode;
30651 inodeList = pInode;
30662 static int fileHasMoved(unixFile *pFile){
30664 return pFile->pInode!=0 && pFile->pId!=pFile->pInode->fileId.pId;
30667 return pFile->pInode!=0 &&
30668 (osStat(pFile->zPath, &buf)!=0 || buf.st_ino!=pFile->pInode->fileId.ino);
30682 static void verifyDbFile(unixFile *pFile){
30687 if( pFile->ctrlFlags & UNIXFILE_NOLOCK )
return;
30689 rc = osFstat(pFile->h, &buf);
30691 sqlite3_log(SQLITE_WARNING,
"cannot fstat db file %s", pFile->zPath);
30694 if( buf.st_nlink==0 ){
30695 sqlite3_log(SQLITE_WARNING,
"file unlinked while open: %s", pFile->zPath);
30698 if( buf.st_nlink>1 ){
30699 sqlite3_log(SQLITE_WARNING,
"multiple links to file: %s", pFile->zPath);
30702 if( fileHasMoved(pFile) ){
30703 sqlite3_log(SQLITE_WARNING,
"file renamed while open: %s", pFile->zPath);
30715 static int unixCheckReservedLock(
sqlite3_file *
id,
int *pResOut){
30716 int rc = SQLITE_OK;
30718 unixFile *pFile = (unixFile*)
id;
30720 SimulateIOError(
return SQLITE_IOERR_CHECKRESERVEDLOCK; );
30723 assert( pFile->eFileLock<=SHARED_LOCK );
30727 if( pFile->pInode->eFileLock>SHARED_LOCK ){
30734 if( !reserved && !pFile->pInode->bProcessLock ){
30736 lock.l_whence = SEEK_SET;
30737 lock.l_start = RESERVED_BYTE;
30739 lock.l_type = F_WRLCK;
30740 if( osFcntl(pFile->h, F_GETLK, &lock) ){
30741 rc = SQLITE_IOERR_CHECKRESERVEDLOCK;
30742 storeLastErrno(pFile, errno);
30743 }
else if( lock.l_type!=F_UNLCK ){
30750 OSTRACE((
"TEST WR-LOCK %d %d %d (unix)\n", pFile->h, rc, reserved));
30752 *pResOut = reserved;
30775 static int unixFileLock(unixFile *pFile,
struct flock *pLock){
30777 unixInodeInfo *pInode = pFile->pInode;
30778 assert( unixMutexHeld() );
30779 assert( pInode!=0 );
30780 if( (pFile->ctrlFlags & (UNIXFILE_EXCL|UNIXFILE_RDONLY))==UNIXFILE_EXCL ){
30781 if( pInode->bProcessLock==0 ){
30783 assert( pInode->nLock==0 );
30784 lock.l_whence = SEEK_SET;
30785 lock.l_start = SHARED_FIRST;
30786 lock.l_len = SHARED_SIZE;
30787 lock.l_type = F_WRLCK;
30788 rc = osFcntl(pFile->h, F_SETLK, &lock);
30789 if( rc<0 )
return rc;
30790 pInode->bProcessLock = 1;
30796 rc = osFcntl(pFile->h, F_SETLK, pLock);
30865 int rc = SQLITE_OK;
30866 unixFile *pFile = (unixFile*)
id;
30867 unixInodeInfo *pInode;
30872 OSTRACE((
"LOCK %d %s was %s(%s,%d) pid=%d (unix)\n", pFile->h,
30873 azFileLock(eFileLock), azFileLock(pFile->eFileLock),
30874 azFileLock(pFile->pInode->eFileLock), pFile->pInode->nShared,
30881 if( pFile->eFileLock>=eFileLock ){
30882 OSTRACE((
"LOCK %d %s ok (already held) (unix)\n", pFile->h,
30883 azFileLock(eFileLock)));
30892 assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
30893 assert( eFileLock!=PENDING_LOCK );
30894 assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
30899 pInode = pFile->pInode;
30904 if( (pFile->eFileLock!=pInode->eFileLock &&
30905 (pInode->eFileLock>=PENDING_LOCK || eFileLock>SHARED_LOCK))
30915 if( eFileLock==SHARED_LOCK &&
30916 (pInode->eFileLock==SHARED_LOCK || pInode->eFileLock==RESERVED_LOCK) ){
30917 assert( eFileLock==SHARED_LOCK );
30918 assert( pFile->eFileLock==0 );
30919 assert( pInode->nShared>0 );
30920 pFile->eFileLock = SHARED_LOCK;
30932 lock.l_whence = SEEK_SET;
30933 if( eFileLock==SHARED_LOCK
30934 || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock<PENDING_LOCK)
30936 lock.l_type = (eFileLock==SHARED_LOCK?F_RDLCK:F_WRLCK);
30937 lock.l_start = PENDING_BYTE;
30938 if( unixFileLock(pFile, &lock) ){
30940 rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
30941 if( rc!=SQLITE_BUSY ){
30942 storeLastErrno(pFile, tErrno);
30952 if( eFileLock==SHARED_LOCK ){
30953 assert( pInode->nShared==0 );
30954 assert( pInode->eFileLock==0 );
30955 assert( rc==SQLITE_OK );
30958 lock.l_start = SHARED_FIRST;
30959 lock.l_len = SHARED_SIZE;
30960 if( unixFileLock(pFile, &lock) ){
30962 rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
30966 lock.l_start = PENDING_BYTE;
30968 lock.l_type = F_UNLCK;
30969 if( unixFileLock(pFile, &lock) && rc==SQLITE_OK ){
30972 rc = SQLITE_IOERR_UNLOCK;
30976 if( rc!=SQLITE_BUSY ){
30977 storeLastErrno(pFile, tErrno);
30981 pFile->eFileLock = SHARED_LOCK;
30983 pInode->nShared = 1;
30985 }
else if( eFileLock==EXCLUSIVE_LOCK && pInode->nShared>1 ){
30994 assert( 0!=pFile->eFileLock );
30995 lock.l_type = F_WRLCK;
30997 assert( eFileLock==RESERVED_LOCK || eFileLock==EXCLUSIVE_LOCK );
30998 if( eFileLock==RESERVED_LOCK ){
30999 lock.l_start = RESERVED_BYTE;
31002 lock.l_start = SHARED_FIRST;
31003 lock.l_len = SHARED_SIZE;
31006 if( unixFileLock(pFile, &lock) ){
31008 rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
31009 if( rc!=SQLITE_BUSY ){
31010 storeLastErrno(pFile, tErrno);
31016 #ifdef SQLITE_DEBUG 31023 && pFile->eFileLock<=SHARED_LOCK
31024 && eFileLock==RESERVED_LOCK
31026 pFile->transCntrChng = 0;
31027 pFile->dbUpdate = 0;
31028 pFile->inNormalWrite = 1;
31033 if( rc==SQLITE_OK ){
31034 pFile->eFileLock = eFileLock;
31035 pInode->eFileLock = eFileLock;
31036 }
else if( eFileLock==EXCLUSIVE_LOCK ){
31037 pFile->eFileLock = PENDING_LOCK;
31038 pInode->eFileLock = PENDING_LOCK;
31043 OSTRACE((
"LOCK %d %s %s (unix)\n", pFile->h, azFileLock(eFileLock),
31044 rc==SQLITE_OK ?
"ok" :
"failed"));
31052 static void setPendingFd(unixFile *pFile){
31053 unixInodeInfo *pInode = pFile->pInode;
31054 UnixUnusedFd *p = pFile->pUnused;
31055 p->pNext = pInode->pUnused;
31056 pInode->pUnused = p;
31058 pFile->pUnused = 0;
31074 static int posixUnlock(
sqlite3_file *
id,
int eFileLock,
int handleNFSUnlock){
31075 unixFile *pFile = (unixFile*)
id;
31076 unixInodeInfo *pInode;
31078 int rc = SQLITE_OK;
31081 OSTRACE((
"UNLOCK %d %d was %d(%d,%d) pid=%d (unix)\n", pFile->h, eFileLock,
31082 pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared,
31085 assert( eFileLock<=SHARED_LOCK );
31086 if( pFile->eFileLock<=eFileLock ){
31090 pInode = pFile->pInode;
31091 assert( pInode->nShared!=0 );
31092 if( pFile->eFileLock>SHARED_LOCK ){
31093 assert( pInode->eFileLock==pFile->eFileLock );
31095 #ifdef SQLITE_DEBUG 31104 pFile->inNormalWrite = 0;
31116 if( eFileLock==SHARED_LOCK ){
31117 #if !defined(__APPLE__) || !SQLITE_ENABLE_LOCKING_STYLE 31118 (void)handleNFSUnlock;
31119 assert( handleNFSUnlock==0 );
31121 #if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE 31122 if( handleNFSUnlock ){
31124 off_t divSize = SHARED_SIZE - 1;
31126 lock.l_type = F_UNLCK;
31127 lock.l_whence = SEEK_SET;
31128 lock.l_start = SHARED_FIRST;
31129 lock.l_len = divSize;
31130 if( unixFileLock(pFile, &lock)==(-1) ){
31132 rc = SQLITE_IOERR_UNLOCK;
31133 storeLastErrno(pFile, tErrno);
31136 lock.l_type = F_RDLCK;
31137 lock.l_whence = SEEK_SET;
31138 lock.l_start = SHARED_FIRST;
31139 lock.l_len = divSize;
31140 if( unixFileLock(pFile, &lock)==(-1) ){
31142 rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_RDLOCK);
31143 if( IS_LOCK_ERROR(rc) ){
31144 storeLastErrno(pFile, tErrno);
31148 lock.l_type = F_UNLCK;
31149 lock.l_whence = SEEK_SET;
31150 lock.l_start = SHARED_FIRST+divSize;
31151 lock.l_len = SHARED_SIZE-divSize;
31152 if( unixFileLock(pFile, &lock)==(-1) ){
31154 rc = SQLITE_IOERR_UNLOCK;
31155 storeLastErrno(pFile, tErrno);
31161 lock.l_type = F_RDLCK;
31162 lock.l_whence = SEEK_SET;
31163 lock.l_start = SHARED_FIRST;
31164 lock.l_len = SHARED_SIZE;
31165 if( unixFileLock(pFile, &lock) ){
31172 rc = SQLITE_IOERR_RDLOCK;
31173 storeLastErrno(pFile, errno);
31178 lock.l_type = F_UNLCK;
31179 lock.l_whence = SEEK_SET;
31180 lock.l_start = PENDING_BYTE;
31181 lock.l_len = 2L; assert( PENDING_BYTE+1==RESERVED_BYTE );
31182 if( unixFileLock(pFile, &lock)==0 ){
31183 pInode->eFileLock = SHARED_LOCK;
31185 rc = SQLITE_IOERR_UNLOCK;
31186 storeLastErrno(pFile, errno);
31190 if( eFileLock==NO_LOCK ){
31196 if( pInode->nShared==0 ){
31197 lock.l_type = F_UNLCK;
31198 lock.l_whence = SEEK_SET;
31199 lock.l_start = lock.l_len = 0L;
31200 if( unixFileLock(pFile, &lock)==0 ){
31201 pInode->eFileLock = NO_LOCK;
31203 rc = SQLITE_IOERR_UNLOCK;
31204 storeLastErrno(pFile, errno);
31205 pInode->eFileLock = NO_LOCK;
31206 pFile->eFileLock = NO_LOCK;
31215 assert( pInode->nLock>=0 );
31216 if( pInode->nLock==0 ){
31217 closePendingFds(pFile);
31223 if( rc==SQLITE_OK ) pFile->eFileLock = eFileLock;
31234 static int unixUnlock(
sqlite3_file *
id,
int eFileLock){
31235 #if SQLITE_MAX_MMAP_SIZE>0 31236 assert( eFileLock==SHARED_LOCK || ((unixFile *)
id)->nFetchOut==0 );
31238 return posixUnlock(
id, eFileLock, 0);
31241 #if SQLITE_MAX_MMAP_SIZE>0 31242 static int unixMapfile(unixFile *pFd, i64 nByte);
31243 static void unixUnmapfile(unixFile *pFd);
31257 unixFile *pFile = (unixFile*)
id;
31258 #if SQLITE_MAX_MMAP_SIZE>0 31259 unixUnmapfile(pFile);
31262 robust_close(pFile, pFile->h, __LINE__);
31267 if( pFile->ctrlFlags & UNIXFILE_DELETE ){
31268 osUnlink(pFile->pId->zCanonicalName);
31270 vxworksReleaseFileId(pFile->pId);
31274 #ifdef SQLITE_UNLINK_AFTER_CLOSE 31275 if( pFile->ctrlFlags & UNIXFILE_DELETE ){
31276 osUnlink(pFile->zPath);
31277 sqlite3_free(*(
char**)&pFile->zPath);
31281 OSTRACE((
"CLOSE %-3d\n", pFile->h));
31283 sqlite3_free(pFile->pUnused);
31284 memset(pFile, 0,
sizeof(unixFile));
31292 int rc = SQLITE_OK;
31293 unixFile *pFile = (unixFile *)
id;
31294 verifyDbFile(pFile);
31295 unixUnlock(
id, NO_LOCK);
31301 assert( pFile->pInode->nLock>0 || pFile->pInode->bProcessLock==0 );
31302 if( ALWAYS(pFile->pInode) && pFile->pInode->nLock ){
31308 setPendingFd(pFile);
31310 releaseInodeInfo(pFile);
31311 rc = closeUnixFile(
id);
31336 static int nolockCheckReservedLock(
sqlite3_file *NotUsed,
int *pResOut){
31337 UNUSED_PARAMETER(NotUsed);
31341 static int nolockLock(
sqlite3_file *NotUsed,
int NotUsed2){
31342 UNUSED_PARAMETER2(NotUsed, NotUsed2);
31345 static int nolockUnlock(
sqlite3_file *NotUsed,
int NotUsed2){
31346 UNUSED_PARAMETER2(NotUsed, NotUsed2);
31354 return closeUnixFile(
id);
31386 #define DOTLOCK_SUFFIX ".lock" 31398 static int dotlockCheckReservedLock(
sqlite3_file *
id,
int *pResOut) {
31399 int rc = SQLITE_OK;
31401 unixFile *pFile = (unixFile*)
id;
31403 SimulateIOError(
return SQLITE_IOERR_CHECKRESERVEDLOCK; );
31406 reserved = osAccess((
const char*)pFile->lockingContext, 0)==0;
31407 OSTRACE((
"TEST WR-LOCK %d %d %d (dotlock)\n", pFile->h, rc, reserved));
31408 *pResOut = reserved;
31439 static int dotlockLock(
sqlite3_file *
id,
int eFileLock) {
31440 unixFile *pFile = (unixFile*)
id;
31441 char *zLockFile = (
char *)pFile->lockingContext;
31442 int rc = SQLITE_OK;
31448 if( pFile->eFileLock > NO_LOCK ){
31449 pFile->eFileLock = eFileLock;
31452 utime(zLockFile, NULL);
31454 utimes(zLockFile, NULL);
31460 rc = osMkdir(zLockFile, 0777);
31463 int tErrno = errno;
31464 if( EEXIST == tErrno ){
31467 rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
31468 if( rc!=SQLITE_BUSY ){
31469 storeLastErrno(pFile, tErrno);
31476 pFile->eFileLock = eFileLock;
31489 static int dotlockUnlock(
sqlite3_file *
id,
int eFileLock) {
31490 unixFile *pFile = (unixFile*)
id;
31491 char *zLockFile = (
char *)pFile->lockingContext;
31495 OSTRACE((
"UNLOCK %d %d was %d pid=%d (dotlock)\n", pFile->h, eFileLock,
31496 pFile->eFileLock, osGetpid(0)));
31497 assert( eFileLock<=SHARED_LOCK );
31500 if( pFile->eFileLock==eFileLock ){
31507 if( eFileLock==SHARED_LOCK ){
31508 pFile->eFileLock = SHARED_LOCK;
31513 assert( eFileLock==NO_LOCK );
31514 rc = osRmdir(zLockFile);
31516 int tErrno = errno;
31517 if( tErrno==ENOENT ){
31520 rc = SQLITE_IOERR_UNLOCK;
31521 storeLastErrno(pFile, tErrno);
31525 pFile->eFileLock = NO_LOCK;
31533 unixFile *pFile = (unixFile*)
id;
31535 dotlockUnlock(
id, NO_LOCK);
31536 sqlite3_free(pFile->lockingContext);
31537 return closeUnixFile(
id);
31556 #if SQLITE_ENABLE_LOCKING_STYLE 31562 static int robust_flock(
int fd,
int op){
31564 do{ rc = flock(fd,op); }
while( rc<0 && errno==EINTR );
31568 # define robust_flock(a,b) flock(a,b) 31578 static int flockCheckReservedLock(
sqlite3_file *
id,
int *pResOut){
31579 int rc = SQLITE_OK;
31581 unixFile *pFile = (unixFile*)
id;
31583 SimulateIOError(
return SQLITE_IOERR_CHECKRESERVEDLOCK; );
31588 if( pFile->eFileLock>SHARED_LOCK ){
31595 int lrc = robust_flock(pFile->h, LOCK_EX | LOCK_NB);
31598 lrc = robust_flock(pFile->h, LOCK_UN);
31600 int tErrno = errno;
31602 lrc = SQLITE_IOERR_UNLOCK;
31603 storeLastErrno(pFile, tErrno);
31607 int tErrno = errno;
31610 lrc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
31611 if( IS_LOCK_ERROR(lrc) ){
31612 storeLastErrno(pFile, tErrno);
31617 OSTRACE((
"TEST WR-LOCK %d %d %d (flock)\n", pFile->h, rc, reserved));
31619 #ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS 31620 if( (rc & SQLITE_IOERR) == SQLITE_IOERR ){
31625 *pResOut = reserved;
31658 static int flockLock(
sqlite3_file *
id,
int eFileLock) {
31659 int rc = SQLITE_OK;
31660 unixFile *pFile = (unixFile*)
id;
31666 if (pFile->eFileLock > NO_LOCK) {
31667 pFile->eFileLock = eFileLock;
31673 if (robust_flock(pFile->h, LOCK_EX | LOCK_NB)) {
31674 int tErrno = errno;
31676 rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_LOCK);
31677 if( IS_LOCK_ERROR(rc) ){
31678 storeLastErrno(pFile, tErrno);
31682 pFile->eFileLock = eFileLock;
31684 OSTRACE((
"LOCK %d %s %s (flock)\n", pFile->h, azFileLock(eFileLock),
31685 rc==SQLITE_OK ?
"ok" :
"failed"));
31686 #ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS 31687 if( (rc & SQLITE_IOERR) == SQLITE_IOERR ){
31702 static int flockUnlock(
sqlite3_file *
id,
int eFileLock) {
31703 unixFile *pFile = (unixFile*)
id;
31706 OSTRACE((
"UNLOCK %d %d was %d pid=%d (flock)\n", pFile->h, eFileLock,
31707 pFile->eFileLock, osGetpid(0)));
31708 assert( eFileLock<=SHARED_LOCK );
31711 if( pFile->eFileLock==eFileLock ){
31716 if (eFileLock==SHARED_LOCK) {
31717 pFile->eFileLock = eFileLock;
31722 if( robust_flock(pFile->h, LOCK_UN) ){
31723 #ifdef SQLITE_IGNORE_FLOCK_LOCK_ERRORS 31726 return SQLITE_IOERR_UNLOCK;
31728 pFile->eFileLock = NO_LOCK;
31738 flockUnlock(
id, NO_LOCK);
31739 return closeUnixFile(
id);
31765 static int semXCheckReservedLock(
sqlite3_file *
id,
int *pResOut) {
31766 int rc = SQLITE_OK;
31768 unixFile *pFile = (unixFile*)
id;
31770 SimulateIOError(
return SQLITE_IOERR_CHECKRESERVEDLOCK; );
31775 if( pFile->eFileLock>SHARED_LOCK ){
31781 sem_t *pSem = pFile->pInode->pSem;
31783 if( sem_trywait(pSem)==-1 ){
31784 int tErrno = errno;
31785 if( EAGAIN != tErrno ){
31786 rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_CHECKRESERVEDLOCK);
31787 storeLastErrno(pFile, tErrno);
31790 reserved = (pFile->eFileLock < SHARED_LOCK);
31797 OSTRACE((
"TEST WR-LOCK %d %d %d (sem)\n", pFile->h, rc, reserved));
31799 *pResOut = reserved;
31832 static int semXLock(
sqlite3_file *
id,
int eFileLock) {
31833 unixFile *pFile = (unixFile*)
id;
31834 sem_t *pSem = pFile->pInode->pSem;
31835 int rc = SQLITE_OK;
31839 if (pFile->eFileLock > NO_LOCK) {
31840 pFile->eFileLock = eFileLock;
31846 if( sem_trywait(pSem)==-1 ){
31852 pFile->eFileLock = eFileLock;
31865 static int semXUnlock(
sqlite3_file *
id,
int eFileLock) {
31866 unixFile *pFile = (unixFile*)
id;
31867 sem_t *pSem = pFile->pInode->pSem;
31871 OSTRACE((
"UNLOCK %d %d was %d pid=%d (sem)\n", pFile->h, eFileLock,
31872 pFile->eFileLock, osGetpid(0)));
31873 assert( eFileLock<=SHARED_LOCK );
31876 if( pFile->eFileLock==eFileLock ){
31881 if (eFileLock==SHARED_LOCK) {
31882 pFile->eFileLock = eFileLock;
31887 if ( sem_post(pSem)==-1 ) {
31888 int rc, tErrno = errno;
31889 rc = sqliteErrorFromPosixError(tErrno, SQLITE_IOERR_UNLOCK);
31890 if( IS_LOCK_ERROR(rc) ){
31891 storeLastErrno(pFile, tErrno);
31895 pFile->eFileLock = NO_LOCK;
31904 unixFile *pFile = (unixFile*)
id;
31905 semXUnlock(
id, NO_LOCK);
31908 releaseInodeInfo(pFile);
31933 #if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE 31937 typedef struct afpLockingContext afpLockingContext;
31938 struct afpLockingContext {
31940 const char *dbPath;
31943 struct ByteRangeLockPB2
31945 unsigned long long offset;
31946 unsigned long long length;
31947 unsigned long long retRangeStart;
31948 unsigned char unLockFlag;
31949 unsigned char startEndFlag;
31953 #define afpfsByteRangeLock2FSCTL _IOWR('z', 23, struct ByteRangeLockPB2) 31961 static int afpSetLock(
31964 unsigned long long offset,
31965 unsigned long long length,
31968 struct ByteRangeLockPB2 pb;
31971 pb.unLockFlag = setLockFlag ? 0 : 1;
31972 pb.startEndFlag = 0;
31973 pb.offset = offset;
31974 pb.length = length;
31977 OSTRACE((
"AFPSETLOCK [%s] for %d%s in range %llx:%llx\n",
31978 (setLockFlag?
"ON":
"OFF"), pFile->h, (pb.fd==-1?
"[testval-1]":
""),
31980 err = fsctl(path, afpfsByteRangeLock2FSCTL, &pb, 0);
31983 int tErrno = errno;
31984 OSTRACE((
"AFPSETLOCK failed to fsctl() '%s' %d %s\n",
31985 path, tErrno, strerror(tErrno)));
31986 #ifdef SQLITE_IGNORE_AFP_LOCK_ERRORS 31989 rc = sqliteErrorFromPosixError(tErrno,
31990 setLockFlag ? SQLITE_IOERR_LOCK : SQLITE_IOERR_UNLOCK);
31992 if( IS_LOCK_ERROR(rc) ){
31993 storeLastErrno(pFile, tErrno);
32007 static int afpCheckReservedLock(
sqlite3_file *
id,
int *pResOut){
32008 int rc = SQLITE_OK;
32010 unixFile *pFile = (unixFile*)
id;
32011 afpLockingContext *context;
32013 SimulateIOError(
return SQLITE_IOERR_CHECKRESERVEDLOCK; );
32016 context = (afpLockingContext *) pFile->lockingContext;
32017 if( context->reserved ){
32024 if( pFile->pInode->eFileLock>SHARED_LOCK ){
32032 int lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1);
32033 if( SQLITE_OK==lrc ){
32036 lrc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0);
32041 if( IS_LOCK_ERROR(lrc) ){
32047 OSTRACE((
"TEST WR-LOCK %d %d %d (afp)\n", pFile->h, rc, reserved));
32049 *pResOut = reserved;
32078 int rc = SQLITE_OK;
32079 unixFile *pFile = (unixFile*)
id;
32080 unixInodeInfo *pInode = pFile->pInode;
32081 afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
32084 OSTRACE((
"LOCK %d %s was %s(%s,%d) pid=%d (afp)\n", pFile->h,
32085 azFileLock(eFileLock), azFileLock(pFile->eFileLock),
32086 azFileLock(pInode->eFileLock), pInode->nShared , osGetpid(0)));
32092 if( pFile->eFileLock>=eFileLock ){
32093 OSTRACE((
"LOCK %d %s ok (already held) (afp)\n", pFile->h,
32094 azFileLock(eFileLock)));
32103 assert( pFile->eFileLock!=NO_LOCK || eFileLock==SHARED_LOCK );
32104 assert( eFileLock!=PENDING_LOCK );
32105 assert( eFileLock!=RESERVED_LOCK || pFile->eFileLock==SHARED_LOCK );
32110 pInode = pFile->pInode;
32115 if( (pFile->eFileLock!=pInode->eFileLock &&
32116 (pInode->eFileLock>=PENDING_LOCK || eFileLock>SHARED_LOCK))
32126 if( eFileLock==SHARED_LOCK &&
32127 (pInode->eFileLock==SHARED_LOCK || pInode->eFileLock==RESERVED_LOCK) ){
32128 assert( eFileLock==SHARED_LOCK );
32129 assert( pFile->eFileLock==0 );
32130 assert( pInode->nShared>0 );
32131 pFile->eFileLock = SHARED_LOCK;
32141 if( eFileLock==SHARED_LOCK
32142 || (eFileLock==EXCLUSIVE_LOCK && pFile->eFileLock<PENDING_LOCK)
32145 failed = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 1);
32155 if( eFileLock==SHARED_LOCK ){
32156 int lrc1, lrc2, lrc1Errno = 0;
32159 assert( pInode->nShared==0 );
32160 assert( pInode->eFileLock==0 );
32162 mask = (
sizeof(long)==8) ? LARGEST_INT64 : 0x7fffffff;
32166 pInode->sharedByte = (lk & mask)%(SHARED_SIZE - 1);
32167 lrc1 = afpSetLock(context->dbPath, pFile,
32168 SHARED_FIRST+pInode->sharedByte, 1, 1);
32169 if( IS_LOCK_ERROR(lrc1) ){
32170 lrc1Errno = pFile->lastErrno;
32173 lrc2 = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0);
32175 if( IS_LOCK_ERROR(lrc1) ) {
32176 storeLastErrno(pFile, lrc1Errno);
32179 }
else if( IS_LOCK_ERROR(lrc2) ){
32182 }
else if( lrc1 != SQLITE_OK ) {
32185 pFile->eFileLock = SHARED_LOCK;
32187 pInode->nShared = 1;
32189 }
else if( eFileLock==EXCLUSIVE_LOCK && pInode->nShared>1 ){
32199 assert( 0!=pFile->eFileLock );
32200 if (eFileLock >= RESERVED_LOCK && pFile->eFileLock < RESERVED_LOCK) {
32202 failed = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1,1);
32204 context->reserved = 1;
32207 if (!failed && eFileLock == EXCLUSIVE_LOCK) {
32213 if( !(failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST +
32214 pInode->sharedByte, 1, 0)) ){
32215 int failed2 = SQLITE_OK;
32217 failed = afpSetLock(context->dbPath, pFile, SHARED_FIRST,
32219 if( failed && (failed2 = afpSetLock(context->dbPath, pFile,
32220 SHARED_FIRST + pInode->sharedByte, 1, 1)) ){
32224 rc = ((failed & SQLITE_IOERR) == SQLITE_IOERR) ? failed2 :
32237 if( rc==SQLITE_OK ){
32238 pFile->eFileLock = eFileLock;
32239 pInode->eFileLock = eFileLock;
32240 }
else if( eFileLock==EXCLUSIVE_LOCK ){
32241 pFile->eFileLock = PENDING_LOCK;
32242 pInode->eFileLock = PENDING_LOCK;
32247 OSTRACE((
"LOCK %d %s %s (afp)\n", pFile->h, azFileLock(eFileLock),
32248 rc==SQLITE_OK ?
"ok" :
"failed"));
32259 static int afpUnlock(
sqlite3_file *
id,
int eFileLock) {
32260 int rc = SQLITE_OK;
32261 unixFile *pFile = (unixFile*)
id;
32262 unixInodeInfo *pInode;
32263 afpLockingContext *context = (afpLockingContext *) pFile->lockingContext;
32264 int skipShared = 0;
32270 OSTRACE((
"UNLOCK %d %d was %d(%d,%d) pid=%d (afp)\n", pFile->h, eFileLock,
32271 pFile->eFileLock, pFile->pInode->eFileLock, pFile->pInode->nShared,
32274 assert( eFileLock<=SHARED_LOCK );
32275 if( pFile->eFileLock<=eFileLock ){
32279 pInode = pFile->pInode;
32280 assert( pInode->nShared!=0 );
32281 if( pFile->eFileLock>SHARED_LOCK ){
32282 assert( pInode->eFileLock==pFile->eFileLock );
32283 SimulateIOErrorBenign(1);
32284 SimulateIOError( h=(-1) )
32285 SimulateIOErrorBenign(0);
32287 #ifdef SQLITE_DEBUG 32296 assert( pFile->inNormalWrite==0
32297 || pFile->dbUpdate==0
32298 || pFile->transCntrChng==1 );
32299 pFile->inNormalWrite = 0;
32302 if( pFile->eFileLock==EXCLUSIVE_LOCK ){
32303 rc = afpSetLock(context->dbPath, pFile, SHARED_FIRST, SHARED_SIZE, 0);
32304 if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1) ){
32306 int sharedLockByte = SHARED_FIRST+pInode->sharedByte;
32307 rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 1);
32312 if( rc==SQLITE_OK && pFile->eFileLock>=PENDING_LOCK ){
32313 rc = afpSetLock(context->dbPath, pFile, PENDING_BYTE, 1, 0);
32315 if( rc==SQLITE_OK && pFile->eFileLock>=RESERVED_LOCK && context->reserved ){
32316 rc = afpSetLock(context->dbPath, pFile, RESERVED_BYTE, 1, 0);
32318 context->reserved = 0;
32321 if( rc==SQLITE_OK && (eFileLock==SHARED_LOCK || pInode->nShared>1)){
32322 pInode->eFileLock = SHARED_LOCK;
32325 if( rc==SQLITE_OK && eFileLock==NO_LOCK ){
32331 unsigned long long sharedLockByte = SHARED_FIRST+pInode->sharedByte;
32333 if( pInode->nShared==0 ){
32334 SimulateIOErrorBenign(1);
32335 SimulateIOError( h=(-1) )
32336 SimulateIOErrorBenign(0);
32338 rc = afpSetLock(context->dbPath, pFile, sharedLockByte, 1, 0);
32341 pInode->eFileLock = NO_LOCK;
32342 pFile->eFileLock = NO_LOCK;
32345 if( rc==SQLITE_OK ){
32347 assert( pInode->nLock>=0 );
32348 if( pInode->nLock==0 ){
32349 closePendingFds(pFile);
32355 if( rc==SQLITE_OK ) pFile->eFileLock = eFileLock;
32363 int rc = SQLITE_OK;
32364 unixFile *pFile = (unixFile*)
id;
32366 afpUnlock(
id, NO_LOCK);
32368 if( pFile->pInode && pFile->pInode->nLock ){
32374 setPendingFd(pFile);
32376 releaseInodeInfo(pFile);
32377 sqlite3_free(pFile->lockingContext);
32378 rc = closeUnixFile(
id);
32396 #if defined(__APPLE__) && SQLITE_ENABLE_LOCKING_STYLE 32404 static int nfsUnlock(
sqlite3_file *
id,
int eFileLock){
32405 return posixUnlock(
id, eFileLock, 1);
32440 static int seekAndRead(unixFile *
id, sqlite3_int64 offset,
void *pBuf,
int cnt){
32443 #if (!defined(USE_PREAD) && !defined(USE_PREAD64)) 32447 assert( cnt==(cnt&0x1ffff) );
32450 #if defined(USE_PREAD) 32451 got = osPread(id->h, pBuf, cnt, offset);
32452 SimulateIOError( got = -1 );
32453 #elif defined(USE_PREAD64) 32454 got = osPread64(id->h, pBuf, cnt, offset);
32455 SimulateIOError( got = -1 );
32457 newOffset = lseek(id->h, offset, SEEK_SET);
32458 SimulateIOError( newOffset = -1 );
32460 storeLastErrno((unixFile*)
id, errno);
32463 got = osRead(id->h, pBuf, cnt);
32465 if( got==cnt )
break;
32467 if( errno==EINTR ){ got = 1;
continue; }
32469 storeLastErrno((unixFile*)
id, errno);
32475 pBuf = (
void*)(got + (
char*)pBuf);
32479 OSTRACE((
"READ %-3d %5d %7lld %llu\n",
32480 id->h, got+prior, offset-prior, TIMER_ELAPSED));
32489 static int unixRead(
32493 sqlite3_int64 offset
32495 unixFile *pFile = (unixFile *)
id;
32498 assert( offset>=0 );
32504 assert( pFile->pUnused==0
32505 || offset>=PENDING_BYTE+512
32506 || offset+amt<=PENDING_BYTE
32510 #if SQLITE_MAX_MMAP_SIZE>0 32513 if( offset<pFile->mmapSize ){
32514 if( offset+amt <= pFile->mmapSize ){
32515 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt);
32518 int nCopy = pFile->mmapSize - offset;
32519 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], nCopy);
32520 pBuf = &((u8 *)pBuf)[nCopy];
32527 got = seekAndRead(pFile, offset, pBuf, amt);
32532 return SQLITE_IOERR_READ;
32534 storeLastErrno(pFile, 0);
32536 memset(&((
char*)pBuf)[got], 0, amt-got);
32537 return SQLITE_IOERR_SHORT_READ;
32548 static int seekAndWriteFd(
32557 assert( nBuf==(nBuf&0x1ffff) );
32559 assert( piErrno!=0 );
32563 #if defined(USE_PREAD) 32564 do{ rc = (int)osPwrite(fd, pBuf, nBuf, iOff); }
while( rc<0 && errno==EINTR );
32565 #elif defined(USE_PREAD64) 32566 do{ rc = (int)osPwrite64(fd, pBuf, nBuf, iOff);}
while( rc<0 && errno==EINTR);
32569 i64 iSeek = lseek(fd, iOff, SEEK_SET);
32570 SimulateIOError( iSeek = -1 );
32575 rc = osWrite(fd, pBuf, nBuf);
32576 }
while( rc<0 && errno==EINTR );
32580 OSTRACE((
"WRITE %-3d %5d %7lld %llu\n", fd, rc, iOff, TIMER_ELAPSED));
32582 if( rc<0 ) *piErrno = errno;
32594 static int seekAndWrite(unixFile *
id, i64 offset,
const void *pBuf,
int cnt){
32595 return seekAndWriteFd(id->h, offset, pBuf, cnt, &id->lastErrno);
32603 static int unixWrite(
32607 sqlite3_int64 offset
32609 unixFile *pFile = (unixFile*)
id;
32617 assert( pFile->pUnused==0
32618 || offset>=PENDING_BYTE+512
32619 || offset+amt<=PENDING_BYTE
32623 #ifdef SQLITE_DEBUG 32630 if( pFile->inNormalWrite ){
32631 pFile->dbUpdate = 1;
32632 if( offset<=24 && offset+amt>=27 ){
32635 SimulateIOErrorBenign(1);
32636 rc = seekAndRead(pFile, 24, oldCntr, 4);
32637 SimulateIOErrorBenign(0);
32638 if( rc!=4 || memcmp(oldCntr, &((
char*)pBuf)[24-offset], 4)!=0 ){
32639 pFile->transCntrChng = 1;
32645 #if defined(SQLITE_MMAP_READWRITE) && SQLITE_MAX_MMAP_SIZE>0 32648 if( offset<pFile->mmapSize ){
32649 if( offset+amt <= pFile->mmapSize ){
32650 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt);
32653 int nCopy = pFile->mmapSize - offset;
32654 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, nCopy);
32655 pBuf = &((u8 *)pBuf)[nCopy];
32662 while( (wrote = seekAndWrite(pFile, offset, pBuf, amt))<amt && wrote>0 ){
32665 pBuf = &((
char*)pBuf)[wrote];
32667 SimulateIOError(( wrote=(-1), amt=1 ));
32668 SimulateDiskfullError(( wrote=0, amt=1 ));
32671 if( wrote<0 && pFile->lastErrno!=ENOSPC ){
32673 return SQLITE_IOERR_WRITE;
32675 storeLastErrno(pFile, 0);
32676 return SQLITE_FULL;
32688 SQLITE_API
int sqlite3_sync_count = 0;
32689 SQLITE_API
int sqlite3_fullsync_count = 0;
32698 #if !defined(fdatasync) && !HAVE_FDATASYNC 32699 # define fdatasync fsync 32708 # define HAVE_FULLFSYNC 1 32710 # define HAVE_FULLFSYNC 0 32738 static int full_fsync(
int fd,
int fullSync,
int dataOnly){
32745 #ifdef SQLITE_NO_SYNC 32746 UNUSED_PARAMETER(fd);
32747 UNUSED_PARAMETER(fullSync);
32748 UNUSED_PARAMETER(dataOnly);
32749 #elif HAVE_FULLFSYNC 32750 UNUSED_PARAMETER(dataOnly);
32752 UNUSED_PARAMETER(fullSync);
32753 UNUSED_PARAMETER(dataOnly);
32761 if( fullSync ) sqlite3_fullsync_count++;
32762 sqlite3_sync_count++;
32770 #ifdef SQLITE_NO_SYNC 32773 rc = osFstat(fd, &buf);
32775 #elif HAVE_FULLFSYNC 32777 rc = osFcntl(fd, F_FULLFSYNC, 0);
32789 if( rc ) rc = fsync(fd);
32791 #elif defined(__APPLE__) 32797 rc = fdatasync(fd);
32799 if( rc==-1 && errno==ENOTSUP ){
32805 if( OS_VXWORKS && rc!= -1 ){
32834 static int openDirectory(
const char *zFilename,
int *pFd){
32837 char zDirname[MAX_PATHNAME+1];
32839 sqlite3_snprintf(MAX_PATHNAME, zDirname,
"%s", zFilename);
32840 for(ii=(
int)strlen(zDirname); ii>0 && zDirname[ii]!=
'/'; ii--);
32842 zDirname[ii] =
'\0';
32844 if( zDirname[0]!=
'/' ) zDirname[0] =
'.';
32847 fd = robust_open(zDirname, O_RDONLY|O_BINARY, 0);
32849 OSTRACE((
"OPENDIR %-3d %s\n", fd, zDirname));
32852 if( fd>=0 )
return SQLITE_OK;
32853 return unixLogError(SQLITE_CANTOPEN_BKPT,
"openDirectory", zDirname);
32873 unixFile *pFile = (unixFile*)
id;
32875 int isDataOnly = (flags&SQLITE_SYNC_DATAONLY);
32876 int isFullsync = (flags&0x0F)==SQLITE_SYNC_FULL;
32879 assert((flags&0x0F)==SQLITE_SYNC_NORMAL
32880 || (flags&0x0F)==SQLITE_SYNC_FULL